@hed-hog/core 0.0.298 → 0.0.300

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

@@ -642,6 +642,153 @@ export class DashboardCoreService {
     return value.map((provider) => String(provider).toLowerCase());
   }
 
+  private slugifyDashboardName(value: string): string {
+    const normalized = value
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '');
+
+    return normalized || `dashboard-${Date.now()}`;
+  }
+
+  private getDashboardDisplayName(
+    dashboard: {
+      slug: string;
+      dashboard_locale?: Array<{ name?: string | null }>;
+    },
+  ): string {
+    return dashboard.dashboard_locale?.[0]?.name || dashboard.slug;
+  }
+
+  private async buildUniqueDashboardSlug(baseSlug: string): Promise<string> {
+    let slug = baseSlug;
+    let suffix = 2;
+
+    while (
+      await this.prismaService.dashboard.findFirst({
+        where: { slug },
+        select: { id: true },
+      })
+    ) {
+      slug = `${baseSlug}-${suffix}`;
+      suffix += 1;
+    }
+
+    return slug;
+  }
+
+  private async getDashboardUserOrThrow(
+    userId: number,
+    slug: string,
+    locale: string,
+  ) {
+    const dashboardUser = await this.prismaService.dashboard_user.findFirst({
+      where: {
+        user_id: userId,
+        dashboard: { slug },
+      },
+      include: {
+        dashboard: {
+          include: {
+            dashboard_locale: {
+              where: {
+                locale: {
+                  code: locale,
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!dashboardUser) {
+      throw new ForbiddenException(
+        getLocaleText('dashboardNotFound', locale, 'Dashboard not found.'),
+      );
+    }
+
+    return dashboardUser;
+  }
+
+  private async getUserRoleIds(userId: number) {
+    const roleUsers = await this.prismaService.role_user.findMany({
+      where: { user_id: userId },
+      select: { role_id: true },
+    });
+
+    return roleUsers.map((roleUser) => roleUser.role_id);
+  }
+
+  private async getAccessibleTemplateOrThrow(
+    userId: number,
+    templateSlug: string,
+    locale: string,
+  ) {
+    const userRoleIds = await this.getUserRoleIds(userId);
+    const templateAccessFilter =
+      userRoleIds.length > 0
+        ? {
+            OR: [
+              {
+                dashboard_role: {
+                  some: {
+                    role_id: {
+                      in: userRoleIds,
+                    },
+                  },
+                },
+              },
+              {
+                dashboard_role: {
+                  none: {},
+                },
+              },
+            ],
+          }
+        : {
+            dashboard_role: {
+              none: {},
+            },
+          };
+
+    const template = await this.prismaService.dashboard.findFirst({
+      where: {
+        slug: templateSlug,
+        is_template: true,
+        ...templateAccessFilter,
+      },
+      include: {
+        dashboard_locale: {
+          where: {
+            locale: {
+              code: locale,
+            },
+          },
+        },
+        dashboard_item: {
+          select: {
+            component_id: true,
+            width: true,
+            height: true,
+            x_axis: true,
+            y_axis: true,
+          },
+        },
+      },
+    });
+
+    if (!template) {
+      throw new ForbiddenException(
+        getLocaleText('dashboardNotFound', locale, 'Dashboard template not found.'),
+      );
+    }
+
+    return template;
+  }
+
   async getHome(userId: number, locale: string) {
     const user = await this.prismaService.user.findUnique({
       where: { id: userId },
@@ -1014,6 +1161,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,
@@ -1060,28 +1208,34 @@ export class DashboardCoreService {
       throw new ForbiddenException('Access denied to this dashboard');
     }
 
-    for (const item of layout) {
-      const itemId = parseInt(item.i.replace('widget-', ''));
-      const dashboardItem = await this.prismaService.dashboard_item.findFirst({
-        where: {
-          id: itemId,
-          dashboard_id: dashboard.id,
-        },
-      });
+    const layoutUpdates = layout.flatMap((item) => {
+      const itemId = Number.parseInt(item.i.replace('widget-', ''), 10);
 
-      if (!dashboardItem) {
-        continue;
+      if (Number.isNaN(itemId)) {
+        this.logger.warn(
+          `Skipping dashboard layout item with invalid id: ${item.i}`,
+        );
+        return [];
       }
 
-      await this.prismaService.dashboard_item.update({
-        where: { id: dashboardItem.id },
-        data: {
-          x_axis: item.x,
-          y_axis: item.y,
-          width: item.w,
-          height: item.h,
-        },
-      });
+      return [
+        this.prismaService.dashboard_item.updateMany({
+          where: {
+            id: itemId,
+            dashboard_id: dashboard.id,
+          },
+          data: {
+            x_axis: item.x,
+            y_axis: item.y,
+            width: item.w,
+            height: item.h,
+          },
+        }),
+      ];
+    });
+
+    if (layoutUpdates.length > 0) {
+      await this.prismaService.$transaction(layoutUpdates);
     }
 
     return { success: true };
@@ -1113,8 +1267,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 +1323,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 +1334,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 +1356,7 @@ export class DashboardCoreService {
           width: component.width,
           height: component.height,
           x_axis: 0,
-          y_axis: 0,
+          y_axis: nextAvailableY,
         },
       });
     }
@@ -1156,6 +1367,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 +1387,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) {
@@ -1222,6 +1478,8 @@ export class DashboardCoreService {
   }
 
   async getUserDashboards(userId: number, locale: string) {
+    await this.getHome(userId, locale);
+
     const dashboardUsers = await this.prismaService.dashboard_user.findMany({
       where: { user_id: userId },
       include: {
@@ -1237,6 +1495,7 @@ export class DashboardCoreService {
           },
         },
       },
+      orderBy: [{ is_home: 'desc' }, { id: 'asc' }],
     });
 
     const uniqueByDashboardId = new Map<number, (typeof dashboardUsers)[number]>();
@@ -1249,10 +1508,509 @@ export class DashboardCoreService {
     return Array.from(uniqueByDashboardId.values()).map((dashboardUser) => ({
       id: dashboardUser.dashboard.id,
       slug: dashboardUser.dashboard.slug,
+      name: this.getDashboardDisplayName(dashboardUser.dashboard),
+      icon: dashboardUser.dashboard.icon,
+      is_home: dashboardUser.is_home,
       dashboard_locale: dashboardUser.dashboard.dashboard_locale,
     }));
   }
 
+  async getAvailableTemplates(userId: number, locale: string) {
+    const userRoleIds = await this.getUserRoleIds(userId);
+    const templateAccessFilter =
+      userRoleIds.length > 0
+        ? {
+            OR: [
+              {
+                dashboard_role: {
+                  some: {
+                    role_id: {
+                      in: userRoleIds,
+                    },
+                  },
+                },
+              },
+              {
+                dashboard_role: {
+                  none: {},
+                },
+              },
+            ],
+          }
+        : {
+            dashboard_role: {
+              none: {},
+            },
+          };
+
+    const templates = await this.prismaService.dashboard.findMany({
+      where: {
+        is_template: true,
+        ...templateAccessFilter,
+      },
+      include: {
+        dashboard_locale: {
+          where: {
+            locale: {
+              code: locale,
+            },
+          },
+        },
+        dashboard_item: {
+          select: { id: true },
+        },
+      },
+      orderBy: [{ id: 'asc' }],
+    });
+
+    return templates.map((template) => ({
+      id: template.id,
+      slug: template.slug,
+      name: this.getDashboardDisplayName(template),
+      icon: template.icon,
+      itemCount: template.dashboard_item.length,
+    }));
+  }
+
+  async createUserDashboard(
+    userId: number,
+    data: { name?: string; slug?: string; icon?: string | null; templateSlug?: string },
+    locale: string,
+  ) {
+    const templateSlug = this.toNullableString(data?.templateSlug);
+    const template = templateSlug
+      ? await this.getAccessibleTemplateOrThrow(userId, templateSlug, locale)
+      : null;
+
+    const templateName = template ? this.getDashboardDisplayName(template) : null;
+    const name = this.toNullableString(data?.name) || templateName;
+
+    if (!name) {
+      throw new BadRequestException(
+        getLocaleText('validation.fieldRequired', locale, 'Dashboard name is required.'),
+      );
+    }
+
+    const requestedSlug = this.toNullableString(data?.slug);
+    const baseSlug = this.slugifyDashboardName(requestedSlug || name);
+    const slug = await this.buildUniqueDashboardSlug(baseSlug);
+    const icon =
+      data?.icon === undefined
+        ? template?.icon ?? null
+        : this.toNullableString(data?.icon) ?? template?.icon ?? null;
+
+    const [localeRecord, existingCount] = await Promise.all([
+      this.prismaService.locale.findFirst({
+        where: { code: locale },
+        select: { id: true },
+      }),
+      this.prismaService.dashboard_user.count({
+        where: { user_id: userId },
+      }),
+    ]);
+
+    const dashboard = await this.prismaService.dashboard.create({
+      data: {
+        slug,
+        icon,
+      },
+    });
+
+    if (localeRecord) {
+      await this.prismaService.dashboard_locale.create({
+        data: {
+          dashboard_id: dashboard.id,
+          locale_id: localeRecord.id,
+          name,
+        },
+      });
+    }
+
+    await this.prismaService.dashboard_user.create({
+      data: {
+        dashboard_id: dashboard.id,
+        user_id: userId,
+        is_home: existingCount === 0,
+      },
+    });
+
+    if (template?.dashboard_item?.length) {
+      await this.prismaService.dashboard_item.createMany({
+        data: template.dashboard_item.map((item) => ({
+          dashboard_id: dashboard.id,
+          component_id: item.component_id,
+          width: item.width,
+          height: item.height,
+          x_axis: item.x_axis,
+          y_axis: item.y_axis,
+        })),
+      });
+    }
+
+    return {
+      id: dashboard.id,
+      slug,
+      name,
+      icon,
+      is_home: existingCount === 0,
+    };
+  }
+
+  async renameUserDashboard(
+    userId: number,
+    slug: string,
+    data: { name?: string; icon?: string | null },
+    locale: string,
+  ) {
+    const dashboardUser = await this.getDashboardUserOrThrow(
+      userId,
+      slug,
+      locale,
+    );
+    const name = this.toNullableString(data?.name);
+    const normalizedIcon =
+      data?.icon === undefined ? undefined : this.toNullableString(data?.icon);
+
+    if (!name && data?.icon === undefined) {
+      throw new BadRequestException(
+        getLocaleText(
+          'validation.fieldRequired',
+          locale,
+          'Dashboard name or icon is required.',
+        ),
+      );
+    }
+
+    if (data?.icon !== undefined) {
+      await this.prismaService.dashboard.update({
+        where: { id: dashboardUser.dashboard_id },
+        data: {
+          icon: normalizedIcon ?? null,
+        },
+      });
+    }
+
+    if (name) {
+      const localeRecord = await this.prismaService.locale.findFirst({
+        where: { code: locale },
+        select: { id: true },
+      });
+
+      if (!localeRecord) {
+        throw new BadRequestException(
+          getLocaleText('localeNotFound', locale, 'Locale not found.'),
+        );
+      }
+
+      const existingLocale = await this.prismaService.dashboard_locale.findFirst({
+        where: {
+          dashboard_id: dashboardUser.dashboard_id,
+          locale_id: localeRecord.id,
+        },
+        select: { id: true },
+      });
+
+      if (existingLocale) {
+        await this.prismaService.dashboard_locale.update({
+          where: { id: existingLocale.id },
+          data: { name },
+        });
+      } else {
+        await this.prismaService.dashboard_locale.create({
+          data: {
+            dashboard_id: dashboardUser.dashboard_id,
+            locale_id: localeRecord.id,
+            name,
+          },
+        });
+      }
+    }
+
+    const updatedDashboard = await this.prismaService.dashboard.findUnique({
+      where: { id: dashboardUser.dashboard_id },
+      include: {
+        dashboard_locale: {
+          where: {
+            locale: {
+              code: locale,
+            },
+          },
+        },
+      },
+    });
+
+    return {
+      success: true,
+      slug,
+      name:
+        name ||
+        (updatedDashboard
+          ? this.getDashboardDisplayName(updatedDashboard)
+          : slug),
+      icon: updatedDashboard?.icon ?? normalizedIcon ?? null,
+    };
+  }
+
+  async setHomeDashboard(userId: number, slug: string, locale: string) {
+    const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+
+    await this.prismaService.dashboard_user.updateMany({
+      where: { user_id: userId },
+      data: { is_home: false },
+    });
+
+    await this.prismaService.dashboard_user.update({
+      where: { id: dashboardUser.id },
+      data: { is_home: true },
+    });
+
+    return {
+      success: true,
+      slug,
+    };
+  }
+
+  async getDashboardShares(userId: number, slug: string, locale: string) {
+    const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+
+    const sharedUsers = await this.prismaService.dashboard_user.findMany({
+      where: {
+        dashboard_id: dashboardUser.dashboard_id,
+      },
+      include: {
+        user: {
+          select: {
+            id: true,
+            name: true,
+            user_identifier: {
+              where: {
+                type: 'email',
+              },
+              select: {
+                value: true,
+              },
+              take: 1,
+            },
+          },
+        },
+      },
+      orderBy: {
+        id: 'asc',
+      },
+    });
+
+    return sharedUsers.map((sharedDashboardUser) => ({
+      id: sharedDashboardUser.user.id,
+      name: sharedDashboardUser.user.name,
+      email: sharedDashboardUser.user.user_identifier[0]?.value ?? null,
+      isCurrentUser: sharedDashboardUser.user.id === userId,
+      isHome: sharedDashboardUser.is_home,
+    }));
+  }
+
+  async getShareableUsers(
+    userId: number,
+    slug: string,
+    search: string | undefined,
+    locale: string,
+  ) {
+    const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+    const normalizedSearch = this.toNullableString(search);
+
+    const existingUsers = await this.prismaService.dashboard_user.findMany({
+      where: {
+        dashboard_id: dashboardUser.dashboard_id,
+      },
+      select: {
+        user_id: true,
+      },
+    });
+
+    const users = await this.prismaService.user.findMany({
+      where: {
+        id: {
+          notIn: existingUsers.map((item) => item.user_id),
+        },
+        ...(normalizedSearch
+          ? {
+              OR: [
+                {
+                  name: {
+                    contains: normalizedSearch,
+                    mode: 'insensitive',
+                  },
+                },
+                {
+                  user_identifier: {
+                    some: {
+                      type: 'email',
+                      value: {
+                        contains: normalizedSearch,
+                        mode: 'insensitive',
+                      },
+                    },
+                  },
+                },
+              ],
+            }
+          : {}),
+      },
+      select: {
+        id: true,
+        name: true,
+        user_identifier: {
+          where: {
+            type: 'email',
+          },
+          select: {
+            value: true,
+          },
+          take: 1,
+        },
+      },
+      take: 20,
+      orderBy: {
+        id: 'desc',
+      },
+    });
+
+    return users.map((candidateUser) => ({
+      id: candidateUser.id,
+      name: candidateUser.name,
+      email: candidateUser.user_identifier[0]?.value ?? null,
+    }));
+  }
+
+  async shareDashboard(
+    userId: number,
+    slug: string,
+    sharedUserId: number | undefined,
+    locale: string,
+  ) {
+    if (!sharedUserId || Number.isNaN(Number(sharedUserId))) {
+      throw new BadRequestException(
+        getLocaleText('validation.fieldRequired', locale, 'User is required.'),
+      );
+    }
+
+    const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+
+    if (sharedUserId === userId) {
+      throw new BadRequestException(
+        getLocaleText(
+          'validation.invalidValue',
+          locale,
+          'You already have access to this dashboard.',
+        ),
+      );
+    }
+
+    const targetUser = await this.prismaService.user.findUnique({
+      where: { id: sharedUserId },
+      select: { id: true },
+    });
+
+    if (!targetUser) {
+      throw new BadRequestException(getLocaleText('userNotFound', locale, 'User not found.'));
+    }
+
+    const existingShare = await this.prismaService.dashboard_user.findFirst({
+      where: {
+        dashboard_id: dashboardUser.dashboard_id,
+        user_id: sharedUserId,
+      },
+      select: { id: true },
+    });
+
+    if (existingShare) {
+      return {
+        success: true,
+        alreadyShared: true,
+      };
+    }
+
+    await this.prismaService.dashboard_user.create({
+      data: {
+        dashboard_id: dashboardUser.dashboard_id,
+        user_id: sharedUserId,
+        is_home: false,
+      },
+    });
+
+    return {
+      success: true,
+    };
+  }
+
+  async revokeDashboardShare(
+    userId: number,
+    slug: string,
+    sharedUserId: number,
+    locale: string,
+  ) {
+    const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+
+    if (sharedUserId === userId) {
+      throw new BadRequestException(
+        getLocaleText(
+          'validation.invalidValue',
+          locale,
+          'Use the remove dashboard action to leave this tab.',
+        ),
+      );
+    }
+
+    await this.prismaService.dashboard_user.deleteMany({
+      where: {
+        dashboard_id: dashboardUser.dashboard_id,
+        user_id: sharedUserId,
+      },
+    });
+
+    return {
+      success: true,
+    };
+  }
+
+  async removeUserDashboard(userId: number, slug: string, locale: string) {
+    const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+
+    await this.prismaService.dashboard_user.delete({
+      where: { id: dashboardUser.id },
+    });
+
+    if (dashboardUser.is_home) {
+      const nextDashboard = await this.prismaService.dashboard_user.findFirst({
+        where: { user_id: userId },
+        orderBy: { id: 'asc' },
+      });
+
+      if (nextDashboard) {
+        await this.prismaService.dashboard_user.update({
+          where: { id: nextDashboard.id },
+          data: { is_home: true },
+        });
+      }
+    }
+
+    const remainingShares = await this.prismaService.dashboard_user.count({
+      where: {
+        dashboard_id: dashboardUser.dashboard_id,
+      },
+    });
+
+    if (remainingShares === 0) {
+      await this.prismaService.dashboard.delete({
+        where: { id: dashboardUser.dashboard_id },
+      });
+    }
+
+    return {
+      success: true,
+      removedSlug: slug,
+    };
+  }
+
   async getAccountSecurity(userId: number) {
     const now = new Date();
     const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);