@hed-hog/core 0.0.298 → 0.0.300

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

@@ -2,15 +2,24 @@ import { getLocaleText } from '@hed-hog/api-locale';
 import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-  forwardRef,
-  Inject,
-  Injectable,
-  NotFoundException
+    BadRequestException,
+    ForbiddenException,
+    forwardRef,
+    Inject,
+    Injectable,
+    NotFoundException,
 } from '@nestjs/common';
+import { existsSync, promises as fs } from 'fs';
+import { join, resolve } from 'path';
 import {
-  CreateDashboardComponentDTO,
-  UpdateDashboardComponentDTO,
+    CreateDashboardComponentDTO,
+    UpdateDashboardComponentDTO,
 } from './dto';
+type DashboardComponentUserPagination = PaginationDTO & {
+  librarySlug?: string;
+  exclude?: string;
+};
+
 @Injectable()
 export class DashboardComponentService {
   constructor(
@@ -21,7 +30,7 @@ export class DashboardComponentService {
   ) {}
 
   async getAllComponents(paginationParams: PaginationDTO) {
-    const fields = ['slug']
+    const fields = ['slug', 'library_slug']
     const OR = this.prismaService.createInsensitiveSearch(
       fields,
       paginationParams,
@@ -75,7 +84,10 @@ export class DashboardComponentService {
     );
   }
 
-  async getAllComponentsByUserRole(paginationParams: PaginationDTO, userId: number) {
+  async getAllComponentsByUserRole(
+    paginationParams: DashboardComponentUserPagination,
+    userId: number,
+  ) {
     const userRoles = await this.prismaService.role_user.findMany({
       where: { user_id: userId },
       select: { role_id: true },
@@ -83,7 +95,64 @@ export class DashboardComponentService {
 
     const userRoleIds = userRoles.map((ur) => ur.role_id);
 
-    const fields = ['slug']
+    if (userRoleIds.length === 0) {
+      const emptyResult = await 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',
+      );
+
+      return {
+        ...emptyResult,
+        modules: [],
+      };
+    }
+
+    const requestedLibrarySlug = paginationParams.librarySlug?.trim();
+    const excludedComponents = (paginationParams.exclude ?? '')
+      .split(',')
+      .map((value) => value.trim())
+      .filter(Boolean)
+      .map((value) => {
+        const slugParts = value.split('.').filter(Boolean);
+        const baseSlug = slugParts[slugParts.length - 1] || value;
+        const librarySlug = slugParts.length > 1 ? slugParts[0] : undefined;
+
+        return {
+          slug: baseSlug,
+          ...(librarySlug ? { library_slug: librarySlug } : {}),
+        };
+      });
+
+    const fields = ['slug', 'library_slug'];
     const OR = this.prismaService.createInsensitiveSearch(
       fields,
       paginationParams,
@@ -102,52 +171,87 @@ export class DashboardComponentService {
       });
     }
 
-    return this.paginationService.paginate(
-      this.prismaService.dashboard_component,
-      paginationParams,
+    const baseFilters = [
       {
-        include: {
-          dashboard_component_locale: {
-            include: {
-              locale: true,
+        dashboard_component_role: {
+          some: {
+            role_id: {
+              in: userRoleIds,
             },
           },
-          dashboard_component_role: {
-            include: {
-              role: {
-                include: {
-                  role_locale: {
-                    include: {
-                      locale: true,
+        },
+      },
+      ...(OR.length > 0 ? [{ OR }] : []),
+      ...(excludedComponents.length > 0
+        ? [
+            {
+              NOT: {
+                OR: excludedComponents,
+              },
+            },
+          ]
+        : []),
+    ];
+
+    const [paginatedResult, modules] = await Promise.all([
+      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: {
+            AND: [
+              ...baseFilters,
+              ...(requestedLibrarySlug
+                ? [{ library_slug: requestedLibrarySlug }]
+                : []),
+            ],
+          },
+          orderBy: {
+            created_at: 'desc',
+          },
         },
+        'dashboardComponent',
+      ),
+      this.prismaService.dashboard_component.findMany({
         where: {
-          AND: [
-            {
-              dashboard_component_role: {
-                some: {
-                  role_id: {
-                    in: userRoleIds,
-                  },
-                },
-              },
-            },
-            {
-              OR,
-            },
-          ],
+          AND: baseFilters,
         },
+        select: {
+          library_slug: true,
+        },
+        distinct: ['library_slug'],
         orderBy: {
-          created_at: 'desc',
+          library_slug: 'asc',
         },
-      },
-      'dashboardComponent',
-    );
+      }),
+    ]);
+
+    return {
+      ...paginatedResult,
+      modules: modules
+        .map((component) => component.library_slug)
+        .filter((value): value is string => Boolean(value)),
+    };
   }
 
   async getComponent(id: number, locale: string, userId?: number) {
@@ -221,9 +325,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 +367,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 +430,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.controller.ts

@@ -1,6 +1,16 @@
 import { Role, User } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
-import { Body, Controller, Delete, Get, Param, Post } from '@nestjs/common';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Query,
+} from '@nestjs/common';
 import { DashboardCoreService } from './dashboard-core.service';
 
 @Role()
@@ -43,6 +53,107 @@ export class DashboardCoreController {
     return this.dashboardCoreService.getUserDashboards(user.id, locale);
   }
 
+  @Get('templates')
+  getAvailableTemplates(@User() user, @Locale() locale: string) {
+    return this.dashboardCoreService.getAvailableTemplates(user.id, locale);
+  }
+
+  @Post('dashboard')
+  createUserDashboard(
+    @User() user,
+    @Body() body: { name?: string; slug?: string; icon?: string | null; templateSlug?: string },
+    @Locale() locale: string,
+  ) {
+    return this.dashboardCoreService.createUserDashboard(user.id, body, locale);
+  }
+
+  @Patch('dashboard/:slug')
+  renameUserDashboard(
+    @User() user,
+    @Param('slug') slug: string,
+    @Body() body: { name?: string; icon?: string | null },
+    @Locale() locale: string,
+  ) {
+    return this.dashboardCoreService.renameUserDashboard(
+      user.id,
+      slug,
+      body,
+      locale,
+    );
+  }
+
+  @Post('dashboard/:slug/home')
+  setHomeDashboard(
+    @User() user,
+    @Param('slug') slug: string,
+    @Locale() locale: string,
+  ) {
+    return this.dashboardCoreService.setHomeDashboard(user.id, slug, locale);
+  }
+
+  @Get('dashboard/:slug/shares')
+  getDashboardShares(
+    @User() user,
+    @Param('slug') slug: string,
+    @Locale() locale: string,
+  ) {
+    return this.dashboardCoreService.getDashboardShares(user.id, slug, locale);
+  }
+
+  @Get('shareable-users/:slug')
+  getShareableUsers(
+    @User() user,
+    @Param('slug') slug: string,
+    @Query('search') search: string | undefined,
+    @Locale() locale: string,
+  ) {
+    return this.dashboardCoreService.getShareableUsers(
+      user.id,
+      slug,
+      search,
+      locale,
+    );
+  }
+
+  @Post('dashboard/:slug/share')
+  shareDashboard(
+    @User() user,
+    @Param('slug') slug: string,
+    @Body() body: { userId?: number },
+    @Locale() locale: string,
+  ) {
+    return this.dashboardCoreService.shareDashboard(
+      user.id,
+      slug,
+      body.userId,
+      locale,
+    );
+  }
+
+  @Delete('dashboard/:slug/share/:sharedUserId')
+  revokeDashboardShare(
+    @User() user,
+    @Param('slug') slug: string,
+    @Param('sharedUserId', ParseIntPipe) sharedUserId: number,
+    @Locale() locale: string,
+  ) {
+    return this.dashboardCoreService.revokeDashboardShare(
+      user.id,
+      slug,
+      sharedUserId,
+      locale,
+    );
+  }
+
+  @Delete('dashboard/:slug')
+  removeUserDashboard(
+    @User() user,
+    @Param('slug') slug: string,
+    @Locale() locale: string,
+  ) {
+    return this.dashboardCoreService.removeUserDashboard(user.id, slug, locale);
+  }
+
   @Get('access/:slug')
   checkAccess(@User() user, @Param('slug') slug: string, @Locale() locale: string) {
     return this.dashboardCoreService.checkDashboardAccess(user.id, slug, locale);