@hed-hog/core 0.0.151 → 0.0.153

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';
+

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 };
+  }
 }