@hed-hog/core 0.0.298 → 0.0.299

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

@@ -2,11 +2,15 @@ import { getLocaleText } from '@hed-hog/api-locale';
 import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
+  BadRequestException,
+  ForbiddenException,
   forwardRef,
   Inject,
   Injectable,
   NotFoundException
 } from '@nestjs/common';
+import { existsSync, promises as fs } from 'fs';
+import { join, resolve } from 'path';
 import {
   CreateDashboardComponentDTO,
   UpdateDashboardComponentDTO,
@@ -21,7 +25,7 @@ export class DashboardComponentService {
   ) {}
 
   async getAllComponents(paginationParams: PaginationDTO) {
-    const fields = ['slug']
+    const fields = ['slug', 'library_slug']
     const OR = this.prismaService.createInsensitiveSearch(
       fields,
       paginationParams,
@@ -83,6 +87,42 @@ export class DashboardComponentService {
 
     const userRoleIds = userRoles.map((ur) => ur.role_id);
 
+    if (userRoleIds.length === 0) {
+      return this.paginationService.paginate(
+        this.prismaService.dashboard_component,
+        paginationParams,
+        {
+          include: {
+            dashboard_component_locale: {
+              include: {
+                locale: true,
+              },
+            },
+            dashboard_component_role: {
+              include: {
+                role: {
+                  include: {
+                    role_locale: {
+                      include: {
+                        locale: true,
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          where: {
+            id: -1,
+          },
+          orderBy: {
+            created_at: 'desc',
+          },
+        },
+        'dashboardComponent',
+      );
+    }
+
     const fields = ['slug']
     const OR = this.prismaService.createInsensitiveSearch(
       fields,
@@ -221,9 +261,15 @@ export class DashboardComponentService {
   }
 
   async createComponent(data: CreateDashboardComponentDTO, locale: string) {
+    const normalized = this.normalizeComponentIdentity(
+      data.slug,
+      data.library_slug,
+    );
+
     const component = await this.prismaService.dashboard_component.create({
       data: {
-        slug: data.slug,
+        slug: normalized.slug,
+        library_slug: normalized.library_slug,
         min_width: data.min_width,
         max_width: data.max_width,
         min_height: data.min_height,
@@ -257,10 +303,18 @@ export class DashboardComponentService {
   }
 
   async updateComponent(id: number, data: UpdateDashboardComponentDTO, locale: string) {
+    const normalized = data.slug
+      ? this.normalizeComponentIdentity(data.slug, data.library_slug)
+      : {
+          slug: undefined,
+          library_slug: data.library_slug,
+        };
+
    await this.prismaService.dashboard_component.update({
       where: { id },
       data: {
-        slug: data.slug,
+        slug: normalized.slug,
+        library_slug: normalized.library_slug,
         min_width: data.min_width,
         max_width: data.max_width,
         min_height: data.min_height,
@@ -312,4 +366,97 @@ export class DashboardComponentService {
       where: { id },
     });
   }
+
+  private normalizeComponentIdentity(slug: string, librarySlug?: string | null) {
+    const slugParts = slug.split('.').filter(Boolean);
+    const baseSlug =
+      slugParts.length > 0 ? slugParts[slugParts.length - 1]! : slug;
+    const resolvedLibrarySlug =
+      librarySlug || (slugParts.length > 1 ? slugParts[0]! : 'core');
+
+    return {
+      slug: baseSlug,
+      library_slug: resolvedLibrarySlug,
+    };
+  }
+
+  private buildWidgetAssetSlug(slug: string, librarySlug?: string | null) {
+    const normalized = this.normalizeComponentIdentity(slug, librarySlug);
+
+    return normalized.slug;
+  }
+
+  private resolvePreviewDirectory(): string {
+    const cwd = process.cwd();
+    const candidates = [
+      resolve(cwd, 'libraries/core/hedhog/frontend/public/dashboard-previews'),
+      resolve(cwd, '../libraries/core/hedhog/frontend/public/dashboard-previews'),
+      resolve(cwd, '../../libraries/core/hedhog/frontend/public/dashboard-previews'),
+    ];
+
+    for (const candidate of candidates) {
+      const parentDirectory = resolve(candidate, '..');
+      if (existsSync(parentDirectory)) {
+        return candidate;
+      }
+    }
+
+    return candidates[0];
+  }
+
+  async savePreview(id: number, file: MulterFile, locale: string) {
+    const isDevelopment = process.env.NODE_ENV !== 'production';
+    if (!isDevelopment) {
+      throw new ForbiddenException(
+        getLocaleText('dashboardPreviewOnlyInDevelopment', locale, 'Preview capture is only available in development environment'),
+      );
+    }
+
+    if (!file || !file.buffer) {
+      throw new BadRequestException(
+        getLocaleText('dashboardPreviewFileRequired', locale, 'Preview image file is required'),
+      );
+    }
+
+    if (!file.mimetype?.startsWith('image/')) {
+      throw new BadRequestException(
+        getLocaleText('dashboardPreviewInvalidFileType', locale, 'Preview file must be an image'),
+      );
+    }
+
+    const component = await this.prismaService.dashboard_component.findUnique({
+      where: { id },
+      select: {
+        id: true,
+        slug: true,
+        library_slug: true,
+      },
+    });
+
+    if (!component) {
+      throw new NotFoundException(
+        getLocaleText('dashboardComponentNotFound', locale, 'Dashboard component not found'),
+      );
+    }
+
+    const previewDirectory = this.resolvePreviewDirectory();
+    await fs.mkdir(previewDirectory, { recursive: true });
+
+    const assetSlug = this.buildWidgetAssetSlug(
+      component.slug,
+      component.library_slug,
+    );
+    const fileName = `${assetSlug}.png`;
+    const outputPath = join(previewDirectory, fileName);
+    await fs.writeFile(outputPath, file.buffer);
+
+    return {
+      success: true,
+      componentId: component.id,
+      slug: component.slug,
+      library_slug: component.library_slug,
+      fileName,
+      relativeUrl: `/libraries/${component.library_slug}/dashboard-previews/${fileName}`,
+    };
+  }
 }

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

@@ -5,6 +5,10 @@ export class CreateDTO {
   @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
   slug: string;
 
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  library_slug?: string;
+
   @IsOptional()
   @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
   min_width?: number;

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

@@ -6,6 +6,10 @@ export class UpdateDTO {
   @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
   slug?: string;
 
+  @IsOptional()
+  @IsString({ message: (args) => getLocaleText('validation.stringRequired', args.value) })
+  library_slug?: string;
+
   @IsOptional()
   @IsNumber({}, { message: (args) => getLocaleText('validation.numberRequired', args.value) })
   min_width?: number;

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

@@ -1014,6 +1014,7 @@ export class DashboardCoreService {
         i: `widget-${item.id}`,
         component_id: item.component_id,
         slug: component.slug,
+        library_slug: component.library_slug,
         name: locale?.name || component.slug,
         description: locale?.description || '',
         x: item.x_axis,
@@ -1113,8 +1114,50 @@ export class DashboardCoreService {
       throw new ForbiddenException('Access denied to this dashboard');
     }
 
+    const userRoles = await this.prismaService.role_user.findMany({
+      where: { user_id: userId },
+      select: { role_id: true },
+    });
+
+    const userRoleIds = userRoles.map((item) => item.role_id);
+
+    if (userRoleIds.length === 0) {
+      throw new ForbiddenException('Access denied to this component');
+    }
+
+    const slugParts = componentSlug.split('.').filter(Boolean);
+    const requestedSlug =
+      slugParts.length > 0 ? slugParts[slugParts.length - 1]! : componentSlug;
+    const requestedLibrarySlug =
+      slugParts.length > 1 ? slugParts[0] : undefined;
+
     const component = await this.prismaService.dashboard_component.findFirst({
-      where: { slug: componentSlug },
+      where: {
+        AND: [
+          requestedLibrarySlug
+            ? {
+                OR: [
+                  { slug: componentSlug },
+                  {
+                    slug: requestedSlug,
+                    library_slug: requestedLibrarySlug,
+                  },
+                ],
+              }
+            : {
+                OR: [{ slug: componentSlug }, { slug: requestedSlug }],
+              },
+          {
+            dashboard_component_role: {
+              some: {
+                role_id: {
+                  in: userRoleIds,
+                },
+              },
+            },
+          },
+        ],
+      },
       include: {
         dashboard_component_locale: {
           where: {
@@ -1127,7 +1170,7 @@ export class DashboardCoreService {
     });
 
     if (!component) {
-      throw new Error(`Component with slug '${componentSlug}' not found`);
+      throw new ForbiddenException('Access denied to this component');
     }
 
     let dashboardItem = await this.prismaService.dashboard_item.findFirst({
@@ -1138,6 +1181,21 @@ export class DashboardCoreService {
     });
 
     if (!dashboardItem) {
+      const dashboardItems = await this.prismaService.dashboard_item.findMany({
+        where: {
+          dashboard_id: dashboard.id,
+        },
+        select: {
+          y_axis: true,
+          height: true,
+        },
+      });
+
+      const nextAvailableY = dashboardItems.reduce(
+        (maxY, item) => Math.max(maxY, item.y_axis + item.height),
+        0,
+      );
+
       dashboardItem = await this.prismaService.dashboard_item.create({
         data: {
           dashboard_id: dashboard.id,
@@ -1145,7 +1203,7 @@ export class DashboardCoreService {
           width: component.width,
           height: component.height,
           x_axis: 0,
-          y_axis: 0,
+          y_axis: nextAvailableY,
         },
       });
     }
@@ -1156,6 +1214,7 @@ export class DashboardCoreService {
       i: `widget-${dashboardItem.id}`,
       component_id: component.id,
       slug: component.slug,
+      library_slug: component.library_slug,
       name: locale?.name || component.slug,
       description: locale?.description || '',
       x: dashboardItem.x_axis,
@@ -1175,8 +1234,52 @@ export class DashboardCoreService {
     slug: string,
     widgetId: string,
   ) {
-    
-    throw new Error('Not implemented yet');
+    const dashboard = await this.prismaService.dashboard.findFirst({
+      where: { slug },
+    });
+
+    if (!dashboard) {
+      throw new Error(`Dashboard with slug '${slug}' not found`);
+    }
+
+    const canAccess = await this.prismaService.dashboard_user.findFirst({
+      where: {
+        dashboard_id: dashboard.id,
+        user_id: userId,
+      },
+      select: { id: true },
+    });
+
+    if (!canAccess) {
+      throw new ForbiddenException('Access denied to this dashboard');
+    }
+
+    const parsedWidgetId = Number(widgetId.replace(/^widget-/, ''));
+
+    if (!Number.isInteger(parsedWidgetId) || parsedWidgetId <= 0) {
+      throw new BadRequestException('Invalid widget id');
+    }
+
+    const dashboardItem = await this.prismaService.dashboard_item.findFirst({
+      where: {
+        id: parsedWidgetId,
+        dashboard_id: dashboard.id,
+      },
+      select: { id: true },
+    });
+
+    if (!dashboardItem) {
+      throw new BadRequestException('Widget not found in this dashboard');
+    }
+
+    await this.prismaService.dashboard_item.delete({
+      where: { id: dashboardItem.id },
+    });
+
+    return {
+      success: true,
+      removedWidgetId: `widget-${dashboardItem.id}`,
+    };
   }
 
   async checkDashboardAccess(userId: number, slug: string, locale: string) {