@hed-hog/core 0.0.151 → 0.0.152

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

@@ -1,4 +1,50 @@
-import { PartialType } from '@nestjs/mapped-types';
-import { CreateDTO } from './create.dto';
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsBoolean, IsNotEmpty, IsNumber, 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()
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  path?: string;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  min_width?: number;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  max_width?: number;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  min_height?: number;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  max_height?: number;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  width?: number;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  height?: number;
+
+  @IsOptional()
+  @IsBoolean({ message: (args) => getLocaleText('validation.booleanRequired', args.value) })
+  is_resizable?: boolean;
+
+  @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-core/dashboard-core.controller.ts

@@ -1,7 +1,8 @@
-import { Role } from '@hed-hog/api';
+import { Role, User } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
-import { Controller, Get, Param } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, Post } from '@nestjs/common';
 import { DashboardCoreService } from './dashboard-core.service';
+
 @Role()
 @Controller('dashboard-core')
 export class DashboardCoreController {
@@ -11,4 +12,54 @@ export class DashboardCoreController {
   fromSlug(@Param('slug') slug: string, @Locale() locale) {
     return this.dashboardCoreService.fromSlug(slug, locale);
   }
+
+  @Get('stats/overview')
+  getStatistics() {
+    return this.dashboardCoreService.getStatistics();
+  }
+
+  @Get('stats/user-growth')
+  getUserGrowth() {
+    return this.dashboardCoreService.getUserGrowth();
+  }
+
+  @Get('layout/:slug')
+  getUserLayout(@User() user, @Param('slug') slug: string) {
+    return this.dashboardCoreService.getUserLayout(user.id, slug);
+  }
+
+  @Post('layout/:slug')
+  saveUserLayout(
+    @User() user,
+    @Param('slug') slug: string,
+    @Body() body: { layout: Array<{ i: string; x: number; y: number; w: number; h: number }> },
+  ) {
+    return this.dashboardCoreService.saveUserLayout(user.id, slug, body.layout);
+  }
+
+  @Post('widget/:slug')
+  addWidget(
+    @User() user,
+    @Param('slug') slug: string,
+    @Body() body: { componentSlug: string },
+  ) {
+    return this.dashboardCoreService.addWidgetToUserDashboard(
+      user.id,
+      slug,
+      body.componentSlug,
+    );
+  }
+
+  @Delete('widget/:slug/:widgetId')
+  removeWidget(
+    @User() user,
+    @Param('slug') slug: string,
+    @Param('widgetId') widgetId: string,
+  ) {
+    return this.dashboardCoreService.removeWidgetFromUserDashboard(
+      user.id,
+      slug,
+      widgetId,
+    );
+  }
 }

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

@@ -24,4 +24,275 @@ export class DashboardCoreService {
       },
     });
   }
+
+  async getStatistics() {
+    const now = new Date();
+    const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+    const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+
+    // Total de usuários
+    const totalUsers = await this.prismaService.user.count();
+
+    // Usuários criados nos últimos 7 dias
+    const recentUsers = await this.prismaService.user.count({
+      where: {
+        created_at: {
+          gte: sevenDaysAgo,
+        },
+      },
+    });
+
+    // Usuários ativos (criados nos últimos 30 dias como aproximação)
+    const activeUsers = await this.prismaService.user.count({
+      where: {
+        created_at: {
+          gte: thirtyDaysAgo,
+        },
+      },
+    });
+
+    // Total de roles
+    const totalRoles = await this.prismaService.role.count();
+
+    // Total de menus
+    const totalMenus = await this.prismaService.menu.count();
+
+    // Total de rotas
+    const totalRoutes = await this.prismaService.route.count();
+
+    return {
+      totalUsers,
+      recentUsers,
+      activeUsers,
+      totalRoles,
+      totalMenus,
+      totalRoutes,
+    };
+  }
+
+  async getUserGrowth() {
+    const now = new Date();
+    const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+
+    // Contagem de usuários criados por dia nos últimos 30 dias
+    const usersByDay = await this.prismaService.$queryRaw<
+      Array<{ date: Date; count: bigint }>
+    >`
+      SELECT DATE("created_at") as date, COUNT(*) as count
+      FROM "user"
+      WHERE "created_at" >= ${thirtyDaysAgo}
+      GROUP BY DATE("created_at")
+      ORDER BY date ASC
+    `;
+
+    return usersByDay.map((item) => ({
+      date: item.date,
+      count: Number(item.count),
+    }));
+  }
+
+  async getUserLayout(userId: number, slug: string) {
+    // Busca os itens do dashboard para este slug
+    const dashboardItems = await this.prismaService.dashboard_item.findMany({
+      where: {
+        dashboard: {
+          slug,
+        },
+      },
+      include: {
+        dashboard_user: {
+          where: {
+            user_id: userId,
+          },
+        },
+        dashboard_component: true,
+      },
+    });
+
+    return dashboardItems.map((item) => {
+      const userLayout = item.dashboard_user[0];
+      return {
+        i: `widget-${item.id}`,
+        component_id: item.component_id,
+        slug: item.dashboard_component.slug,
+        x: userLayout?.x_axis ?? item.x_axis ?? 0,
+        y: userLayout?.y_axis ?? item.y_axis ?? 0,
+        w: userLayout?.width ?? item.width ?? 2,
+        h: userLayout?.height ?? item.height ?? 2,
+        minW: item.dashboard_component.min_width,
+        maxW: item.dashboard_component.max_width,
+        minH: item.dashboard_component.min_height,
+        maxH: item.dashboard_component.max_height,
+        isResizable: item.dashboard_component.is_resizable ?? true,
+      };
+    });
+  }
+
+  async saveUserLayout(
+    userId: number,
+    slug: string,
+    layout: Array<{
+      i: string;
+      x: number;
+      y: number;
+      w: number;
+      h: number;
+    }>,
+  ) {
+    // Busca o dashboard
+    const dashboard = await this.prismaService.dashboard.findFirst({
+      where: { slug },
+    });
+
+    if (!dashboard) {
+      throw new Error(`Dashboard with slug '${slug}' not found`);
+    }
+
+    // Para cada item do layout, salva ou atualiza o dashboard_user
+    for (const item of layout) {
+      // Extrai o ID do item do identificador
+      const itemId = parseInt(item.i.replace('widget-', ''));
+
+      // Verifica se o item existe
+      const dashboardItem = await this.prismaService.dashboard_item.findFirst({
+        where: {
+          id: itemId,
+          dashboard_id: dashboard.id,
+        },
+      });
+
+      if (!dashboardItem) {
+        continue;
+      }
+
+      // Busca se já existe um dashboard_user para este item e usuário
+      const existingUserLayout =
+        await this.prismaService.dashboard_user.findFirst({
+          where: {
+            item_id: itemId,
+            user_id: userId,
+          },
+        });
+
+      if (existingUserLayout) {
+        // Atualiza o layout existente
+        await this.prismaService.dashboard_user.update({
+          where: {
+            id: existingUserLayout.id,
+          },
+          data: {
+            x_axis: item.x,
+            y_axis: item.y,
+            width: item.w,
+            height: item.h,
+          },
+        });
+      } else {
+        // Cria um novo layout de usuário
+        await this.prismaService.dashboard_user.create({
+          data: {
+            item_id: itemId,
+            user_id: userId,
+            x_axis: item.x,
+            y_axis: item.y,
+            width: item.w,
+            height: item.h,
+          },
+        });
+      }
+    }
+
+    return { success: true };
+  }
+
+  async addWidgetToUserDashboard(
+    userId: number,
+    slug: string,
+    componentSlug: string,
+  ) {
+    // Busca o dashboard
+    const dashboard = await this.prismaService.dashboard.findFirst({
+      where: { slug },
+    });
+
+    if (!dashboard) {
+      throw new Error(`Dashboard with slug '${slug}' not found`);
+    }
+
+    // Busca o componente
+    const component = await this.prismaService.dashboard_component.findFirst({
+      where: { slug: componentSlug },
+    });
+
+    if (!component) {
+      throw new Error(`Component with slug '${componentSlug}' not found`);
+    }
+
+    // Verifica se já existe um item para este componente no dashboard
+    let dashboardItem = await this.prismaService.dashboard_item.findFirst({
+      where: {
+        dashboard_id: dashboard.id,
+        component_id: component.id,
+      },
+    });
+
+    // Se não existe, cria um novo item
+    if (!dashboardItem) {
+      dashboardItem = await this.prismaService.dashboard_item.create({
+        data: {
+          dashboard_id: dashboard.id,
+          component_id: component.id,
+          width: component.width,
+          height: component.height,
+          x_axis: 0,
+          y_axis: 0,
+        },
+      });
+    }
+
+    // Cria um registro de dashboard_user para este usuário
+    const userLayout = await this.prismaService.dashboard_user.create({
+      data: {
+        item_id: dashboardItem.id,
+        user_id: userId,
+        width: component.width,
+        height: component.height,
+        x_axis: 0,
+        y_axis: 999, // Coloca no final
+      },
+    });
+
+    return {
+      i: `widget-${dashboardItem.id}`,
+      component_id: component.id,
+      slug: component.slug,
+      x: userLayout.x_axis,
+      y: userLayout.y_axis,
+      w: userLayout.width,
+      h: userLayout.height,
+      minW: component.min_width,
+      maxW: component.max_width,
+      minH: component.min_height,
+      maxH: component.max_height,
+      isResizable: component.is_resizable ?? true,
+    };
+  }
+
+  async removeWidgetFromUserDashboard(
+    userId: number,
+    slug: string,
+    widgetId: string,
+  ) {
+    const itemId = parseInt(widgetId.replace('widget-', ''));
+
+    // Remove o dashboard_user
+    await this.prismaService.dashboard_user.deleteMany({
+      where: {
+        item_id: itemId,
+        user_id: userId,
+      },
+    });
+
+    return { success: true };
+  }
 }

package/src/dashboard/dashboard-item/dashboard-item.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,
@@ -8,14 +9,12 @@ import {
   Inject,
   Param,
   ParseIntPipe,
-  Patch,
   Post,
-  forwardRef,
+  Query,
+  forwardRef
 } from '@nestjs/common';
-import { CreateDTO } from './dto/create.dto';
-import { UpdateDTO } from './dto/update.dto';
 import { DashboardItemService } from './dashboard-item.service';
-import { Role, DeleteDTO } from '@hed-hog/api';
+import { CreateDashboardItemDTO } from './dto';
 
 @Role()
 @Controller('dashboard-item')
@@ -26,30 +25,22 @@ export class DashboardItemController {
   ) {}
 
   @Get()
-  async list(@Pagination() paginationParams) {
-    return this.dashboardItemService.list(paginationParams);
-  }
-
-  @Get(':id')
-  async get(@Param('id', ParseIntPipe) id: number) {
-    return this.dashboardItemService.get(id);
+  getAllDashboardItems(
+    @Pagination() paginationParams,
+    @Locale() locale: string,
+    @Query('dashboardId') dashboardId?: string,
+  ) {
+    const id = dashboardId ? parseInt(dashboardId) : undefined;
+    return this.dashboardItemService.getAllDashboardItems(paginationParams, locale, id);
   }
 
   @Post()
-  async create(@Body() data: CreateDTO) {
-    return this.dashboardItemService.create(data);
-  }
-
-  @Patch(':id')
-  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
-    return this.dashboardItemService.update({
-      id,
-      data,
-    });
+  createDashboardItem(@Body() data: CreateDashboardItemDTO, @Locale() locale: string) {
+    return this.dashboardItemService.createDashboardItem(data, locale);
   }
 
-  @Delete()
-  async delete(@Body() data: DeleteDTO) {
-    return this.dashboardItemService.delete(data);
+  @Delete(':id')
+  deleteDashboardItem(@Param('id', ParseIntPipe) id: number, @Locale() locale: string) {
+    return this.dashboardItemService.deleteDashboardItem(id, locale);
   }
 }

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

@@ -1,14 +1,13 @@
-import { DeleteDTO } from '@hed-hog/api';
-import { PaginationDTO, PaginationService } 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 {
-  BadRequestException,
-  Inject,
-  Injectable,
-  forwardRef,
+    forwardRef,
+    Inject,
+    Injectable,
+    NotFoundException
 } from '@nestjs/common';
-import { CreateDTO } from './dto/create.dto';
-import { UpdateDTO } from './dto/update.dto';
+import { CreateDashboardItemDTO } from './dto';
 
 @Injectable()
 export class DashboardItemService {
@@ -17,66 +16,75 @@ export class DashboardItemService {
     private readonly prismaService: PrismaService,
     @Inject(forwardRef(() => PaginationService))
     private readonly paginationService: PaginationService,
+    @Inject(forwardRef(() => LocaleService))
+    private readonly localeService: LocaleService,
   ) {}
 
-  async list(paginationParams: PaginationDTO) {
-    const fields = [];
-    const OR: any[] = this.prismaService.createInsensitiveSearch(
-      fields,
-      paginationParams,
-    );
-
-    if (paginationParams.search && !isNaN(+paginationParams.search)) {
-      OR.push({ id: { equals: +paginationParams.search } });
-    }
-
+  async getAllDashboardItems(paginationParams, locale: string, dashboardId?: number) {
     return this.paginationService.paginate(
       this.prismaService.dashboard_item,
       paginationParams,
       {
-        where: {
-          OR,
-        },
+        where: dashboardId ? { dashboard_id: dashboardId } : undefined,
         include: {
-          dashboard_component: true,
-          dashboard: true,
+          dashboard: {
+            include: {
+              dashboard_locale: {
+                include: {
+                  locale: true,
+                },
+              },
+            },
+          },
+          dashboard_component: {
+            include: {
+              dashboard_component_locale: {
+                include: {
+                  locale: true,
+                },
+              },
+            },
+          },
+        },
+        orderBy: {
+          id: 'desc',
         },
       },
+      'dashboardItem',
     );
   }
 
-  async get(id: number) {
-    return this.prismaService.dashboard_item.findUnique({
-      where: { id: id },
-    });
-  }
-
-  async create(data: CreateDTO) {
+  async createDashboardItem(data: CreateDashboardItemDTO, locale: string) {
     return this.prismaService.dashboard_item.create({
-      data,
+      data: {
+        dashboard_id: data.dashboard_id,
+        component_id: data.component_id,
+        width: data.width,
+        height: data.height,
+        x_axis: data.x_axis,
+        y_axis: data.y_axis,
+      },
+      include: {
+        dashboard: true,
+        dashboard_component: true,
+      },
     });
   }
 
-  async update({ id, data }: { id: number; data: UpdateDTO }) {
-    return this.prismaService.dashboard_item.update({
-      where: { id: id },
-      data,
+  async deleteDashboardItem(id: number, locale: string) {
+    const item = await this.prismaService.dashboard_item.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 (!item) {
+      throw new NotFoundException(
+        getLocaleText('dashboardItemNotFound', locale, 'Dashboard item not found'),
       );
     }
 
-    return this.prismaService.dashboard_item.deleteMany({
-      where: {
-        id: {
-          in: ids,
-        },
-      },
+    await this.prismaService.dashboard_item.delete({
+      where: { id },
     });
+    return { success: true };
   }
 }

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

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

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

@@ -1,4 +1,28 @@
-import { PartialType } from '@nestjs/mapped-types';
-import { CreateDTO } from './create.dto';
+import { getLocaleText } from '@hed-hog/api-locale';
+import { IsNumber, IsOptional } from 'class-validator';
 
-export class UpdateDTO extends PartialType(CreateDTO) {}
+export class UpdateDTO {
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  component_id?: number;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  dashboard_id?: number;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  width?: number;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  height?: number;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  x_axis?: number;
+
+  @IsOptional()
+  @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
+  y_axis?: number;
+}

package/src/dashboard/dashboard.module.ts

@@ -5,13 +5,13 @@ import { DashboardComponentModule } from './dashboard-component/dashboard-compon
 import { DashboardCoreModule } from './dashboard-core/dashboard-core.module';
 import { DashboardItemModule } from './dashboard-item/dashboard-item.module';
 import { DashboardUserModule } from './dashboard-user/dashboard-user.module';
-import { DashboardModule2 } from './dashboard/dashboard.module';
+import { DashboardCrudModule } from './dashboard/dashboard.module';
 
 @Module({
   imports: [
     forwardRef(() => LocaleModule),
     forwardRef(() => PrismaModule),
-    forwardRef(() => DashboardModule2),
+    forwardRef(() => DashboardCrudModule),
     forwardRef(() => DashboardComponentModule),
     forwardRef(() => DashboardItemModule),
     forwardRef(() => DashboardUserModule),

package/src/language/en.json

@@ -167,5 +167,8 @@
   },
   "mail_sent_not_found": "Mail sent record not found.",
   "validationSslugMustBeString": "Slug must be a string.",
-  "sessionRevoked": "Session has been revoked or expired."
+  "sessionRevoked": "Session has been revoked or expired.",
+  "dashboardNotFound": "Dashboard not found.",
+  "dashboardComponentNotFound": "Dashboard component not found.",
+  "dashboardItemNotFound": "Dashboard item not found."
 }

package/src/language/pt.json

@@ -167,5 +167,8 @@
   },
   "mail_sent_not_found": "Registro de e-mail enviado não encontrado.",
   "validationSslugMustBeString": "O slug deve ser uma string.",
-  "sessionRevoked": "Sessão foi revogada ou expirada."
+  "sessionRevoked": "Sessão foi revogada ou expirou.",
+  "dashboardNotFound": "Dashboard não encontrado.",
+  "dashboardComponentNotFound": "Componente de dashboard não encontrado.",
+  "dashboardItemNotFound": "Item de dashboard não encontrado."
 }