@hed-hog/core 0.0.151 → 0.0.152

package/src/dashboard/dashboard/dashboard.controller.ts

@@ -1,4 +1,4 @@
-import { DeleteDTO, Role } from '@hed-hog/api';
+import { Role } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
@@ -9,41 +9,44 @@ import {
   Param,
   ParseIntPipe,
   Patch,
-  Post,
+  Post
 } from '@nestjs/common';
 import { DashboardService } from './dashboard.service';
-import { CreateDTO } from './dto/create.dto';
-import { UpdateDTO } from './dto/update.dto';
+import {
+  CreateDashboardDTO,
+  UpdateDashboardDTO,
+} from './dto';
 @Role()
-@Controller('/dashboard')
+@Controller('dashboard')
 export class DashboardController {
   constructor(private readonly dashboardService: DashboardService) {}
 
   @Get()
-  async list(@Locale() locale, @Pagination() paginationParams) {
-    return this.dashboardService.list(locale, paginationParams);
+  getAllDashboards(@Pagination() paginationParams, @Locale() locale: string) {
+    return this.dashboardService.getAllDashboards(paginationParams, locale);
   }
-
+ 
   @Get(':id')
-  async get(@Param('id', ParseIntPipe) id: number) {
-    return this.dashboardService.get(id);
+  getDashboard(@Param('id', ParseIntPipe) id: number, @Locale() locale: string) {
+    return this.dashboardService.getDashboard(id, locale);
   }
-
+ 
   @Post()
-  async create(@Body() data: CreateDTO) {
-    return this.dashboardService.create(data);
+  createDashboard(@Body() data: CreateDashboardDTO, @Locale() locale: string) {
+    return this.dashboardService.createDashboard(data, locale);
   }
-
+ 
   @Patch(':id')
-  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
-    return this.dashboardService.update({
-      id,
-      data,
-    });
+  updateDashboard(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() data: UpdateDashboardDTO,
+    @Locale() locale: string,
+  ) {
+    return this.dashboardService.updateDashboard(id, data, locale);
   }
-
-  @Delete()
-  async delete(@Body() data: DeleteDTO) {
-    return this.dashboardService.delete(data);
+ 
+  @Delete(':id')
+  deleteDashboard(@Param('id', ParseIntPipe) id: number, @Locale() locale: string) {
+    return this.dashboardService.deleteDashboard(id, locale);
   }
 }

package/src/dashboard/dashboard/dashboard.module.ts

@@ -1,13 +1,18 @@
 import { LocaleModule } from '@hed-hog/api-locale';
+import { PaginationModule } from '@hed-hog/api-pagination';
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
 import { DashboardController } from './dashboard.controller';
 import { DashboardService } from './dashboard.service';
 
 @Module({
-  imports: [forwardRef(() => LocaleModule), forwardRef(() => PrismaModule)],
+  imports: [
+    forwardRef(() => LocaleModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => PaginationModule),
+  ],
   controllers: [DashboardController],
   providers: [DashboardService],
   exports: [forwardRef(() => DashboardService)],
 })
-export class DashboardModule2 {}
+export class DashboardCrudModule {}

package/src/dashboard/dashboard/dashboard.service.ts

@@ -1,71 +1,152 @@
-import { DeleteDTO } from '@hed-hog/api';
-import { LocaleService } from '@hed-hog/api-locale';
-import { PaginationDTO } from '@hed-hog/api-pagination';
+import { getLocaleText, LocaleService } from '@hed-hog/api-locale';
+import { PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
-import { Injectable } from '@nestjs/common';
-import { BadRequestException } from '@nestjs/common/exceptions';
-import { CreateDTO } from './dto/create.dto';
-import { UpdateDTO } from './dto/update.dto';
+import { forwardRef, Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { CreateDashboardDTO, UpdateDashboardDTO } from './dto';
 
 @Injectable()
 export class DashboardService {
   constructor(
-    private readonly localeService: LocaleService,
+    @Inject(forwardRef(() => PrismaService))
     private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+    @Inject(forwardRef(() => LocaleService))
+    private readonly localeService: LocaleService,
   ) {}
-  private readonly modelName = 'dashboard';
-  private readonly foreignKey = 'dashboard_id';
-
-  async list(locale: string, paginationParams: PaginationDTO) {
-    return this.localeService.listModelWithLocale(
-      locale,
-      'dashboard',
+  async getAllDashboards(paginationParams, locale: string) {
+    return this.paginationService.paginate(
+      this.prismaService.dashboard,
       paginationParams,
-      {},
       {
-        dashboard_item: {
-          include: {
-            dashboard_component: true,
+        include: {
+          dashboard_locale: {
+            include: {
+              locale: true,
+            },
           },
         },
+        orderBy: {
+          id: 'desc',
+        },
       },
+      'dashboard',
     );
   }
+ 
+  async getDashboard(id: number, locale: string) {
+    const dashboard = await this.prismaService.dashboard.findUnique({
+      where: { id },
+      include: {
+        dashboard_locale: {
+          include: {
+            locale: true,
+          },
+        },
+        dashboard_item: {
+          include: {
+            dashboard_component: {
+              include: {
+                dashboard_component_locale: {
+                  include: {
+                    locale: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!dashboard) {
+      throw new NotFoundException(
+        getLocaleText('dashboardNotFound', locale, 'Dashboard not found'),
+      );
+    }
 
-  async get(id: number) {
-    return this.localeService.getModelWithLocale(this.modelName, id);
+    return dashboard;
   }
+ 
+  async createDashboard(data: CreateDashboardDTO, locale: string) {
+    const dashboard = await this.prismaService.dashboard.create({
+      data: {
+        slug: data.slug,
+      },
+    });
 
-  async create(data: CreateDTO) {
-    return this.localeService.createModelWithLocale(
-      this.modelName,
-      this.foreignKey,
-      data,
-    );
+    // Criar locales se fornecidos
+    if (data.locale) {
+      for (const [localeCode, localeData] of Object.entries(data.locale)) {
+        const localeRecord = await this.prismaService.locale.findFirst({
+          where: { code: localeCode },
+        });
+
+        if (localeRecord) {
+          await this.prismaService.dashboard_locale.create({
+            data: {
+              dashboard_id: dashboard.id,
+              locale_id: localeRecord.id,
+              name: localeData.name,
+            },
+          });
+        }
+      }
+    }
+
+    return this.getDashboard(dashboard.id, locale);
   }
+ 
+  async updateDashboard(id: number, data: UpdateDashboardDTO, locale: string) {
+    await this.prismaService.dashboard.update({
+      where: { id },
+      data: {
+        slug: data.slug,
+      },
+    });
 
-  async update({ id, data }: { id: number; data: UpdateDTO }) {
-    return this.localeService.updateModelWithLocale(
-      this.modelName,
-      this.foreignKey,
-      id,
-      data,
-    );
+    // Atualizar locales se fornecidos
+    if (data.locale) {
+      // Remove locales existentes
+      await this.prismaService.dashboard_locale.deleteMany({
+        where: { dashboard_id: id },
+      });
+
+      // Criar novos locales
+      for (const [localeCode, localeData] of Object.entries(data.locale)) {
+        const localeRecord = await this.prismaService.locale.findFirst({
+          where: { code: localeCode },
+        });
+
+        if (localeRecord) {
+          await this.prismaService.dashboard_locale.create({
+            data: {
+              dashboard_id: id,
+              locale_id: localeRecord.id,
+              name: localeData.name,
+            },
+          });
+        }
+      }
+    }
+
+    return this.getDashboard(id, locale);
   }
+ 
+  async deleteDashboard(id: number, locale: string) {
+    const dashboard = await this.prismaService.dashboard.findUnique({
+      where: { id },
+    });
 
-  async delete({ ids }: DeleteDTO): Promise<{count:number}> {
-    if (ids == undefined || ids == null) {
-      throw new BadRequestException(
-        'You must select at least one item to delete.',
+    if (!dashboard) {
+      throw new NotFoundException(
+        getLocaleText('dashboardNotFound', locale, 'Dashboard not found'),
       );
     }
 
-    return this.prismaService.dashboard.deleteMany({
-      where: {
-        id: {
-          in: ids,
-        },
-      },
+    await this.prismaService.dashboard.delete({
+      where: { id },
     });
+    return { success: true };
   }
 }

package/src/dashboard/dashboard/dto/create.dto.ts

@@ -1,8 +1,17 @@
-import { getLocaleText, WithLocaleDTO } from '@hed-hog/api-locale';
-import { IsNotEmpty, IsString } from 'class-validator';
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsNotEmpty, IsObject, IsString } from 'class-validator';
 
-export class CreateDTO extends WithLocaleDTO {
+export class CreateDTO {
   @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
   @IsNotEmpty({ message: (args) => getLocaleText('validation.fieldRequired', args.value) })
   slug: string;
+
+  @IsObject({
+    message: (args) =>
+      getLocaleText('validation.localeMustBeObject', args.value),
+  })
+  @IsNotEmpty({
+    message: (args) => getLocaleText('validation.localeRequired', args.value),
+  })
+  locale: Record<string, { name: string }>;
 }

package/src/dashboard/dashboard/dto/index.ts

@@ -0,0 +1,7 @@
+export * from './create.dto';
+export * from './update.dto';
+
+// Aliases para compatibilidade
+export { CreateDTO as CreateDashboardDTO } from './create.dto';
+export { UpdateDTO as UpdateDashboardDTO } from './update.dto';
+

package/src/dashboard/dashboard/dto/update.dto.ts

@@ -1,4 +1,18 @@
-import { PartialType } from '@nestjs/mapped-types';
-import { CreateDTO } from './create.dto';
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsNotEmpty, IsObject, IsOptional, IsString } from 'class-validator';
 
-export class UpdateDTO extends PartialType(CreateDTO) {}
+export class UpdateDTO {
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  slug?: string;
+
+  @IsOptional()
+  @IsObject({
+    message: (args) =>
+      getLocaleText('validation.localeMustBeObject', args.value),
+  })
+  @IsNotEmpty({
+    message: (args) => getLocaleText('validation.localeRequired', args.value),
+  })
+  locale?: Record<string, { name: string }>;
+}

package/src/dashboard/dashboard-component/dashboard-component.controller.ts

@@ -1,5 +1,6 @@
-import { Pagination } from '@hed-hog/api-pagination';
+import { Role } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
+import { Pagination } from '@hed-hog/api-pagination';
 import {
   Body,
   Controller,
@@ -10,12 +11,13 @@ import {
   ParseIntPipe,
   Patch,
   Post,
-  forwardRef,
+  forwardRef
 } from '@nestjs/common';
-import { CreateDTO } from './dto/create.dto';
-import { UpdateDTO } from './dto/update.dto';
 import { DashboardComponentService } from './dashboard-component.service';
-import { Role, DeleteDTO } from '@hed-hog/api';
+import {
+  CreateDashboardComponentDTO,
+  UpdateDashboardComponentDTO,
+} from './dto';
 
 @Role()
 @Controller('dashboard-component')
@@ -26,30 +28,31 @@ export class DashboardComponentController {
   ) {}
 
   @Get()
-  async list(@Locale() locale, @Pagination() paginationParams) {
-    return this.dashboardComponentService.list(locale, paginationParams);
+  getAllComponents(@Pagination() paginationParams) {
+    return this.dashboardComponentService.getAllComponents(paginationParams);
   }
 
   @Get(':id')
-  async get(@Param('id', ParseIntPipe) id: number) {
-    return this.dashboardComponentService.get(id);
+  getComponent(@Param('id', ParseIntPipe) id: number, @Locale() locale: string) {
+    return this.dashboardComponentService.getComponent(id, locale);
   }
 
   @Post()
-  async create(@Body() data: CreateDTO) {
-    return this.dashboardComponentService.create(data);
+  createComponent(@Body() data: CreateDashboardComponentDTO, @Locale() locale: string) {
+    return this.dashboardComponentService.createComponent(data, locale);
   }
 
   @Patch(':id')
-  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
-    return this.dashboardComponentService.update({
-      id,
-      data,
-    });
+  updateComponent(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() data: UpdateDashboardComponentDTO,
+    @Locale() locale: string,
+  ) {
+    return this.dashboardComponentService.updateComponent(id, data, locale);
   }
 
-  @Delete()
-  async delete(@Body() data: DeleteDTO) {
-    return this.dashboardComponentService.delete(data);
+  @Delete(':id')
+  deleteComponent(@Param('id', ParseIntPipe) id: number, @Locale() locale: string) {
+    return this.dashboardComponentService.deleteComponent(id, locale);
   }
 }

package/src/dashboard/dashboard-component/dashboard-component.module.ts

@@ -1,12 +1,12 @@
+import { LocaleModule } from '@hed-hog/api-locale';
 import { PaginationModule } from '@hed-hog/api-pagination';
 import { PrismaModule } from '@hed-hog/api-prisma';
-import { LocaleModule } from '@hed-hog/api-locale';
 import { forwardRef, Module } from '@nestjs/common';
-import { DashboardComponentService } from './dashboard-component.service';
 import { DashboardComponentController } from './dashboard-component.controller';
+import { DashboardComponentService } from './dashboard-component.service';
 
 @Module({
-  imports: [forwardRef(() => LocaleModule), forwardRef(() => PrismaModule)],
+  imports: [forwardRef(() => LocaleModule), forwardRef(() => PaginationModule), forwardRef(() => PrismaModule)],
   controllers: [DashboardComponentController],
   providers: [DashboardComponentService],
   exports: [DashboardComponentService],

package/src/dashboard/dashboard-component/dashboard-component.service.ts

@@ -1,16 +1,16 @@
-import { PaginationDTO } from '@hed-hog/api-pagination';
+import { getLocaleText } from '@hed-hog/api-locale';
+import { PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-  BadRequestException,
+  forwardRef,
   Inject,
   Injectable,
-  forwardRef,
+  NotFoundException
 } from '@nestjs/common';
-import { CreateDTO } from './dto/create.dto';
-import { DeleteDTO } from '@hed-hog/api';
-import { UpdateDTO } from './dto/update.dto';
-import { LocaleService } from '@hed-hog/api-locale';
-
+import {
+  CreateDashboardComponentDTO,
+  UpdateDashboardComponentDTO,
+} from './dto';
 @Injectable()
 export class DashboardComponentService {
   private readonly modelName = 'dashboard_component';
@@ -19,52 +19,141 @@ export class DashboardComponentService {
   constructor(
     @Inject(forwardRef(() => PrismaService))
     private readonly prismaService: PrismaService,
-    @Inject(forwardRef(() => LocaleService))
-    private readonly localeService: LocaleService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
   ) {}
 
-  async list(locale: string, paginationParams: PaginationDTO) {
-    return this.localeService.listModelWithLocale(
-      locale,
-      this.modelName,
+  async getAllComponents(paginationParams) {
+    return this.paginationService.paginate(
+      this.prismaService.dashboard_component,
       paginationParams,
+      {
+        include: {
+          dashboard_component_locale: {
+            include: {
+              locale: true,
+            },
+          },
+        },
+        orderBy: {
+          created_at: 'desc',
+        },
+      },
+      'dashboardComponent',
     );
   }
 
-  async get(id: number) {
-    return this.localeService.getModelWithLocale(this.modelName, id);
+  async getComponent(id: number, locale: string) {
+    const component = await this.prismaService.dashboard_component.findUnique({
+      where: { id },
+      include: {
+        dashboard_component_locale: {
+          include: {
+            locale: true,
+          },
+        },
+      },
+    });
+
+    if (!component) {
+      throw new NotFoundException(
+        getLocaleText('dashboardComponentNotFound', locale, 'Dashboard component not found'),
+      );
+    }
+
+    return component;
   }
 
-  async create(data: CreateDTO) {
-    return this.localeService.createModelWithLocale(
-      this.modelName,
-      this.foreignKey,
-      data,
-    );
+  async createComponent(data: CreateDashboardComponentDTO, locale: string) {
+    const component = await this.prismaService.dashboard_component.create({
+      data: {
+        slug: data.slug,
+        path: data.path,
+        min_width: data.min_width,
+        max_width: data.max_width,
+        min_height: data.min_height,
+        max_height: data.max_height,
+        width: data.width,
+        height: data.height,
+        is_resizable: data.is_resizable ?? true,
+      },
+    });
+
+    if (data.locale) {
+      for (const [localeCode, localeData] of Object.entries(data.locale)) {
+        const localeRecord = await this.prismaService.locale.findFirst({
+          where: { code: localeCode },
+        });
+
+        if (localeRecord) {
+          await this.prismaService.dashboard_component_locale.create({
+            data: {
+              dashboard_component_id: component.id,
+              locale_id: localeRecord.id,
+              name: localeData.name,
+            },
+          });
+        }
+      }
+    }
+
+    return this.getComponent(component.id, locale);
   }
 
-  async update({ id, data }: { id: number; data: UpdateDTO }) {
-    return this.localeService.updateModelWithLocale(
-      this.modelName,
-      this.foreignKey,
-      id,
-      data,
-    );
+  async updateComponent(id: number, data: UpdateDashboardComponentDTO, locale: string) {
+   await this.prismaService.dashboard_component.update({
+      where: { id },
+      data: {
+        slug: data.slug,
+        path: data.path,
+        min_width: data.min_width,
+        max_width: data.max_width,
+        min_height: data.min_height,
+        max_height: data.max_height,
+        width: data.width,
+        height: data.height,
+        is_resizable: data.is_resizable,
+      },
+    });
+
+    if (data.locale) {
+      await this.prismaService.dashboard_component_locale.deleteMany({
+        where: { dashboard_component_id: id },
+      });
+
+      for (const [localeCode, localeData] of Object.entries(data.locale)) {
+        const localeRecord = await this.prismaService.locale.findFirst({
+          where: { code: localeCode },
+        });
+
+        if (localeRecord) {
+          await this.prismaService.dashboard_component_locale.create({
+            data: {
+              dashboard_component_id: id,
+              locale_id: localeRecord.id,
+              name: localeData.name,
+            },
+          });
+        }
+      }
+    }
+
+    return this.getComponent(id, locale);
   }
 
-  async delete({ ids }: DeleteDTO): Promise<{count:number}> {
-    if (ids == undefined || ids == null) {
-      throw new BadRequestException(
-        'You must select at least one item to delete.',
+  async deleteComponent(id: number, locale: string) {
+    const component = await this.prismaService.dashboard_component.findUnique({
+      where: { id },
+    });
+
+    if (!component) {
+      throw new NotFoundException(
+        getLocaleText('dashboardComponentNotFound', locale, 'Dashboard component not found'),
       );
     }
 
-    return this.prismaService.dashboard_component.deleteMany({
-      where: {
-        id: {
-          in: ids,
-        },
-      },
+    return this.prismaService.dashboard_component.delete({
+      where: { id },
     });
   }
 }

package/src/dashboard/dashboard-component/dto/create.dto.ts

@@ -1,7 +1,7 @@
-import { getLocaleText, WithLocaleDTO } from '@hed-hog/api-locale';
-import { IsBoolean, IsNumber, IsOptional, IsString } from 'class-validator';
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsBoolean, IsNotEmpty, IsNumber, IsObject, IsOptional, IsString } from 'class-validator';
 
-export class CreateDTO extends WithLocaleDTO {
+export class CreateDTO {
   @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
   slug: string;
 
@@ -33,4 +33,13 @@ export class CreateDTO extends WithLocaleDTO {
   @IsOptional()
   @IsBoolean({ message: (args) => getLocaleText('validation.booleanRequired', args.value) })
   is_resizable?: boolean;
+
+  @IsObject({
+    message: (args) =>
+      getLocaleText('validation.localeMustBeObject', args.value),
+  })
+  @IsNotEmpty({
+    message: (args) => getLocaleText('validation.localeRequired', args.value),
+  })
+  locale: Record<string, { name: string }>;
 }

package/src/dashboard/dashboard-component/dto/index.ts

@@ -0,0 +1,7 @@
+export * from './create.dto';
+export * from './update.dto';
+
+// Aliases para compatibilidade
+export { CreateDTO as CreateDashboardComponentDTO } from './create.dto';
+export { UpdateDTO as UpdateDashboardComponentDTO } from './update.dto';
+