@hedhog/admin 0.0.103 → 0.0.105

package/src/locale/locale.service.spec.ts

@@ -0,0 +1,193 @@
+import { PaginationService } from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/prisma';
+import { BadRequestException } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import { CreateDTO } from './dto/create.dto';
+import { DeleteDTO } from './dto/delete.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { LocaleService } from './locale.service';
+
+describe('LocaleService', () => {
+  let service: LocaleService;
+  let prismaService: PrismaService;
+  let paginationService: PaginationService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        LocaleService,
+        {
+          provide: PrismaService,
+          useValue: {
+            translation: {
+              findMany: jest.fn(),
+            },
+            locale: {
+              findUnique: jest.fn(),
+              create: jest.fn(),
+              update: jest.fn(),
+              deleteMany: jest.fn(),
+            },
+          },
+        },
+        {
+          provide: PaginationService,
+          useValue: {
+            paginate: jest.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    service = module.get<LocaleService>(LocaleService);
+    prismaService = module.get<PrismaService>(PrismaService);
+    paginationService = module.get<PaginationService>(PaginationService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('getTranslations', () => {
+    it('should throw BadRequestException when localeCode is not provided', async () => {
+      await expect(service.getTranslations('', 'namespace')).rejects.toThrow(
+        BadRequestException,
+      );
+    });
+
+    it('should return translation for a given localeCode and namespace', async () => {
+      const mockTranslations = [
+        {
+          id: 1,
+          locale_id: 1,
+          namespace_id: 1,
+          name: 'hello',
+          value: 'Hello',
+          created_at: new Date(),
+          updated_at: new Date(),
+        },
+      ];
+      jest
+        .spyOn(prismaService.translation, 'findMany')
+        .mockResolvedValue(mockTranslations);
+
+      const result = await service.getTranslations('en-US', 'namespace');
+      expect(result).toEqual({ hello: 'Hello' });
+    });
+  });
+  /*
+  describe('get', () => {
+    it('should paginate locale', async () => {
+      const mockPaginationResult = {
+        data: [],
+        total: 10,
+        lastPage: 1,
+        page: 1,
+        prev: 0,
+        next: 2,
+        pageSize: 10,
+      };
+      jest
+        .spyOn(paginationService, 'paginate')
+        .mockResolvedValue(mockPaginationResult);
+
+      const paginationParams: PaginationDTO = {
+        page: 1,
+        pageSize: 20,
+        sortField: '',
+        sortOrder: PageOrderDirection.Asc,
+        fields: '',
+        search: '',
+      };
+      const result = await service.get(paginationParams );
+
+      expect(paginationService.paginate).toHaveBeenCalledWith(
+        prismaService.locale,
+        paginationParams,
+        expect.anything(),
+      );
+      expect(result).toBe(mockPaginationResult);
+    });
+  });
+*/
+  describe('getById', () => {
+    it('should return a locale by ID', async () => {
+      const mockLocale = {
+        id: 1,
+        name: 'English',
+        code: 'en',
+        region: 'us',
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      jest
+        .spyOn(prismaService.locale, 'findUnique')
+        .mockResolvedValue(mockLocale);
+
+      const result = await service.getById(1);
+      expect(result).toBe(mockLocale);
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new locale', async () => {
+      const mockCreateDTO: CreateDTO = {
+        name: 'English',
+        code: 'en',
+        region: 'us',
+      };
+      const mockLocale = {
+        id: 1,
+        name: 'English',
+        code: 'en',
+        region: 'us',
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      jest.spyOn(prismaService.locale, 'create').mockResolvedValue(mockLocale);
+
+      const result = await service.create(mockCreateDTO);
+      expect(result).toBe(mockLocale);
+    });
+  });
+
+  describe('update', () => {
+    it('should update a locale', async () => {
+      const mockUpdateDTO: UpdateDTO = {
+        name: 'English Updated',
+        code: 'en',
+        region: 'us',
+      };
+      const mockLocale = {
+        id: 1,
+        name: 'English Updated',
+        code: 'en',
+        region: 'us',
+        created_at: new Date(),
+        updated_at: new Date(),
+      };
+      jest.spyOn(prismaService.locale, 'update').mockResolvedValue(mockLocale);
+
+      const result = await service.update({ id: 1, data: mockUpdateDTO });
+      expect(result).toBe(mockLocale);
+    });
+  });
+
+  describe('delete', () => {
+    it('should throw BadRequestException if no IDs are provided', async () => {
+      await expect(service.delete({ ids: null })).rejects.toThrow(
+        BadRequestException,
+      );
+    });
+
+    it('should delete locale by IDs', async () => {
+      const mockDeleteDTO: DeleteDTO = { ids: [1, 2, 3] };
+      jest
+        .spyOn(prismaService.locale, 'deleteMany')
+        .mockResolvedValue({ count: 3 });
+
+      const result = await service.delete(mockDeleteDTO);
+      expect(result.count).toBe(3);
+    });
+  });
+});

package/src/locale/locale.service.ts

@@ -0,0 +1,366 @@
+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_namespaces: {
+        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_namespaces: {
+        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_namespaces: {
+        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) {
+    const modelNames = modelName.split('_');
+    modelNames.push('locale');
+    return modelNames.join('_');
+  }
+
+  async createModelWithLocale<T>(
+    modelName: string,
+    foreginKeyName: string,
+    data: T,
+    locale: Record<string, string>,
+  ) {
+    const model = await this.prismaService[modelName].create({
+      data,
+    });
+
+    for (const localeCode of Object.keys(locale)) {
+      const locale = await this.getByCode(localeCode);
+
+      const data: any = {};
+
+      for (const key of Object.keys(locale[localeCode])) {
+        data[key] = locale[localeCode][key];
+      }
+
+      await this.prismaService[this.getTableNameTranslations(modelName)].create(
+        {
+          data: {
+            [foreginKeyName]: model.id,
+            locale_id: locale.id,
+            ...data,
+          },
+        },
+      );
+    }
+
+    return this.prismaService[modelName].findUnique({
+      where: { id: model.id },
+      include: {
+        [this.getTableNameTranslations(modelName)]: {
+          where: {
+            locale: {
+              enabled: true,
+            },
+          },
+          include: {
+            locale: {
+              select: {
+                code: true,
+              },
+            },
+          },
+        },
+      },
+    });
+  }
+
+  async updateModelWithLocale<T extends any>(
+    modelName: string,
+    foreginKeyName: string,
+    id: number,
+    data: T,
+    locale: Record<string, string>,
+  ) {
+    for (const localeCode of Object.keys(locale)) {
+      const locale = await this.getByCode(localeCode);
+
+      const data: any = {};
+
+      for (const key of Object.keys(locale[localeCode])) {
+        data[key] = locale[localeCode][key];
+      }
+
+      await this.prismaService[this.getTableNameTranslations(modelName)].upsert(
+        {
+          where: {
+            [`${foreginKeyName}_locale_id`]: {
+              [foreginKeyName]: id,
+              locale_id: locale.id,
+            },
+          },
+          create: {
+            [foreginKeyName]: id,
+            locale_id: locale.id,
+            ...data,
+          },
+          update: {
+            ...data,
+          },
+        },
+      );
+    }
+
+    return this.prismaService[modelName].update({
+      where: { id },
+      data,
+    });
+  }
+}

package/src/menu/dto/create.dto.ts

@@ -0,0 +1,25 @@
+import { IsInt, IsNotEmpty, IsOptional, IsString, Min } from 'class-validator';
+
+export class CreateDTO {
+  @IsString({ message: 'O nome deve ser uma string' })
+  @IsNotEmpty({ message: 'O nome é obrigatório.' })
+  name: string;
+
+  @IsString({ message: 'A url deve ser uma string' })
+  @IsNotEmpty({ message: 'A url é obrigatório.' })
+  url: string;
+
+  @IsInt({ message: 'Order deve ser um número.' })
+  @Min(1)
+  @IsOptional()
+  order?: number;
+
+  @IsString({ message: 'O ícone deve ser uma string' })
+  @IsOptional()
+  icon?: string;
+
+  @IsInt({ message: 'MenuID deve ser um número.' })
+  @Min(1)
+  @IsOptional()
+  menuId?: number;
+}

package/src/menu/dto/order.dto.ts

@@ -0,0 +1,8 @@
+import { ArrayMinSize, IsArray, IsInt } from 'class-validator';
+
+export class OrderDTO {
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsInt({ each: true })
+  ids: number[];
+}

package/src/menu/dto/update.dto.ts

@@ -0,0 +1,19 @@
+import { IsInt, IsOptional, IsString } from 'class-validator';
+
+export class UpdateDTO {
+  @IsString({ message: 'O nome deve ser uma string' })
+  @IsOptional()
+  name?: string;
+
+  @IsString({ message: 'A url deve ser uma string' })
+  @IsOptional()
+  url?: string;
+
+  @IsInt({ message: 'Order deve ser um número.' })
+  @IsOptional()
+  order?: number;
+
+  @IsString({ message: 'O ícone deve ser uma string' })
+  @IsOptional()
+  icon?: string;
+}

package/src/menu/menu.controller.ts

@@ -0,0 +1,106 @@
+import { Pagination } from '@hedhog/pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  forwardRef,
+} from '@nestjs/common';
+import { User } from '../auth/decorators/user.decorator';
+import { DeleteDTO } from '../dto/delete.dto';
+import { UpdateIdsDTO } from '../dto/update-ids.dto';
+import { Locale } from '../locale';
+import { Role } from '../role/decorators/role.decorator';
+import { CreateDTO } from './dto/create.dto';
+import { OrderDTO } from './dto/order.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { MenuService } from './menu.service';
+
+@Role()
+@Controller('menu')
+export class MenuController {
+  constructor(
+    @Inject(forwardRef(() => MenuService))
+    private readonly menuService: MenuService,
+  ) {}
+
+  @Get('system')
+  async getSystemMenu(@User() { id }, @Locale() locale) {
+    return this.menuService.getSystemMenu(locale, id);
+  }
+
+  @Get()
+  async getMenu(@Pagination() paginationParams, @Locale() locale) {
+    return this.menuService.getMenu(locale, paginationParams);
+  }
+
+  @Get(':menuId/role')
+  async listRoles(
+    @Param('menuId', ParseIntPipe) menuId: number,
+    @Pagination() paginationParams,
+    @Locale() locale,
+  ) {
+    return this.menuService.listRoles(locale, menuId, paginationParams);
+  }
+
+  @Get(':menuId/screens')
+  async listScreens(
+    @Param('menuId', ParseIntPipe) menuId: number,
+    @Pagination() paginationParams,
+    @Locale() locale,
+  ) {
+    return this.menuService.listScreens(locale, menuId, paginationParams);
+  }
+
+  @Patch(':menuId/role')
+  async updateRoles(
+    @Param('menuId', ParseIntPipe) menuId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.menuService.updateRoles(menuId, data);
+  }
+
+  @Patch(':menuId/screens')
+  async updateScreens(
+    @Param('menuId', ParseIntPipe) menuId: number,
+    @Body() data: UpdateIdsDTO,
+  ) {
+    return this.menuService.updateScreens(menuId, data);
+  }
+
+  @Get(':menuId')
+  async show(@Param('menuId', ParseIntPipe) menuId: number) {
+    return this.menuService.get(menuId);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.menuService.create(data);
+  }
+
+  @Patch(':menuId')
+  async update(
+    @Param('menuId', ParseIntPipe) menuId: number,
+    @Body() data: UpdateDTO,
+  ) {
+    return this.menuService.update({
+      id: menuId,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.menuService.delete(data);
+  }
+
+  @Patch('order')
+  async updateOrder(@Body() data: OrderDTO): Promise<void> {
+    return this.menuService.updateOrder(data);
+  }
+}