@hed-hog/core 0.0.299 → 0.0.301

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

@@ -642,6 +642,241 @@ 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 getDashboardComponentRoleRequirements(dashboardId: number) {
+    const dashboardItems = await this.prismaService.dashboard_item.findMany({
+      where: {
+        dashboard_id: dashboardId,
+      },
+      select: {
+        component_id: true,
+        dashboard_component: {
+          select: {
+            dashboard_component_role: {
+              select: {
+                role_id: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const uniqueByComponentId = new Map<number, number[]>();
+
+    for (const item of dashboardItems) {
+      if (uniqueByComponentId.has(item.component_id)) {
+        continue;
+      }
+
+      uniqueByComponentId.set(
+        item.component_id,
+        item.dashboard_component.dashboard_component_role.map(
+          (relation) => relation.role_id,
+        ),
+      );
+    }
+
+    return Array.from(uniqueByComponentId.values());
+  }
+
+  private userHasRequiredRolesForDashboard(
+    componentRoleRequirements: number[][],
+    userRoleIds: number[],
+  ) {
+    if (componentRoleRequirements.length === 0) {
+      return true;
+    }
+
+    if (userRoleIds.length === 0) {
+      return componentRoleRequirements.every(
+        (requiredRoles) => requiredRoles.length === 0,
+      );
+    }
+
+    const userRoleIdSet = new Set(userRoleIds);
+
+    return componentRoleRequirements.every(
+      (requiredRoles) =>
+        requiredRoles.length === 0 ||
+        requiredRoles.some((roleId) => userRoleIdSet.has(roleId)),
+    );
+  }
+
+  private async getDashboardRoleAccessState(dashboardId: number, userId: number) {
+    const [componentRoleRequirements, userRoleIds] = await Promise.all([
+      this.getDashboardComponentRoleRequirements(dashboardId),
+      this.getUserRoleIds(userId),
+    ]);
+
+    const hasRequiredRoles = this.userHasRequiredRolesForDashboard(
+      componentRoleRequirements,
+      userRoleIds,
+    );
+
+    return {
+      hasRequiredRoles,
+      accessStatus: hasRequiredRoles ? 'allowed' : 'missing-roles',
+    };
+  }
+
+  private async assertDashboardRoleAccess(dashboardId: number, userId: number) {
+    const { hasRequiredRoles } = await this.getDashboardRoleAccessState(
+      dashboardId,
+      userId,
+    );
+
+    if (!hasRequiredRoles) {
+      throw new ForbiddenException('Access denied to this dashboard');
+    }
+  }
+
+  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 },
@@ -986,6 +1221,8 @@ export class DashboardCoreService {
       return [];
     }
 
+    await this.assertDashboardRoleAccess(dashboard.id, userId);
+
     const dashboardItems = await this.prismaService.dashboard_item.findMany({
       where: {
         dashboard_id: dashboard.id,
@@ -1061,28 +1298,36 @@ 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,
-        },
-      });
+    await this.assertDashboardRoleAccess(dashboard.id, userId);
 
-      if (!dashboardItem) {
-        continue;
+    const layoutUpdates = layout.flatMap((item) => {
+      const itemId = Number.parseInt(item.i.replace('widget-', ''), 10);
+
+      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 };
@@ -1114,6 +1359,8 @@ export class DashboardCoreService {
       throw new ForbiddenException('Access denied to this dashboard');
     }
 
+    await this.assertDashboardRoleAccess(dashboard.id, userId);
+
     const userRoles = await this.prismaService.role_user.findMany({
       where: { user_id: userId },
       select: { role_id: true },
@@ -1254,6 +1501,8 @@ export class DashboardCoreService {
       throw new ForbiddenException('Access denied to this dashboard');
     }
 
+    await this.assertDashboardRoleAccess(dashboard.id, userId);
+
     const parsedWidgetId = Number(widgetId.replace(/^widget-/, ''));
 
     if (!Number.isInteger(parsedWidgetId) || parsedWidgetId <= 0) {
@@ -1311,9 +1560,20 @@ export class DashboardCoreService {
       },
     });
 
-    const hasAccess = Boolean(dashboardUser);
+    if (!dashboardUser) {
+      return {
+        hasAccess: false,
+        accessStatus: 'not-shared',
+        dashboard: null,
+      };
+    }
+
+    const roleAccess = await this.getDashboardRoleAccessState(dashboard.id, userId);
+    const hasAccess = roleAccess.hasRequiredRoles;
+
     return {
       hasAccess,
+      accessStatus: roleAccess.accessStatus,
       dashboard: hasAccess
         ? {
             id: dashboard.id,
@@ -1325,6 +1585,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: {
@@ -1340,6 +1602,7 @@ export class DashboardCoreService {
           },
         },
       },
+      orderBy: [{ is_home: 'desc' }, { id: 'asc' }],
     });
 
     const uniqueByDashboardId = new Map<number, (typeof dashboardUsers)[number]>();
@@ -1352,10 +1615,603 @@ 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 dashboardRoleRequirements = await this.getDashboardComponentRoleRequirements(
+      dashboardUser.dashboard_id,
+    );
+
+    const sharedUsers = await this.prismaService.dashboard_user.findMany({
+      where: {
+        dashboard_id: dashboardUser.dashboard_id,
+      },
+      include: {
+        user: {
+          select: {
+            id: true,
+            name: true,
+            role_user: {
+              select: {
+                role_id: true,
+              },
+            },
+            user_identifier: {
+              where: {
+                type: 'email',
+              },
+              select: {
+                value: true,
+              },
+              take: 1,
+            },
+          },
+        },
+      },
+      orderBy: {
+        id: 'asc',
+      },
+    });
+
+    return sharedUsers.map((sharedDashboardUser) => {
+      const userRoleIds = sharedDashboardUser.user.role_user.map(
+        (roleUser) => roleUser.role_id,
+      );
+      const hasRequiredRoles = this.userHasRequiredRolesForDashboard(
+        dashboardRoleRequirements,
+        userRoleIds,
+      );
+
+      return {
+        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,
+        hasRequiredRoles,
+        accessStatus: hasRequiredRoles ? 'allowed' : 'missing-roles',
+      };
+    });
+  }
+
+  async getShareableUsers(
+    userId: number,
+    slug: string,
+    options:
+      | {
+          search?: string;
+          page?: string | number;
+          pageSize?: string | number;
+        }
+      | undefined,
+    locale: string,
+  ) {
+    const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+    const normalizedSearch = this.toNullableString(options?.search);
+    const requestedPage = Number.parseInt(String(options?.page ?? '1'), 10);
+    const requestedPageSize = Number.parseInt(String(options?.pageSize ?? '10'), 10);
+    const page = Number.isFinite(requestedPage) && requestedPage > 0 ? requestedPage : 1;
+    const pageSize = Number.isFinite(requestedPageSize) && requestedPageSize > 0
+      ? Math.min(requestedPageSize, 50)
+      : 10;
+
+    const [existingUsers, dashboardRoleRequirements] = await Promise.all([
+      this.prismaService.dashboard_user.findMany({
+        where: {
+          dashboard_id: dashboardUser.dashboard_id,
+        },
+        select: {
+          user_id: true,
+        },
+      }),
+      this.getDashboardComponentRoleRequirements(dashboardUser.dashboard_id),
+    ]);
+
+    const where: any = {
+      id: {
+        notIn: existingUsers.map((item) => item.user_id),
+      },
+      ...(normalizedSearch
+        ? {
+            OR: [
+              {
+                name: {
+                  contains: normalizedSearch,
+                  mode: 'insensitive' as const,
+                },
+              },
+              {
+                user_identifier: {
+                  some: {
+                    type: 'email',
+                    value: {
+                      contains: normalizedSearch,
+                      mode: 'insensitive' as const,
+                    },
+                  },
+                },
+              },
+            ],
+          }
+        : {}),
+    };
+
+    const total = await this.prismaService.user.count({ where });
+    const lastPage = total > 0 ? Math.ceil(total / pageSize) : 1;
+    const safePage = Math.min(page, lastPage);
+
+    const users = await this.prismaService.user.findMany({
+      where,
+      select: {
+        id: true,
+        name: true,
+        role_user: {
+          select: {
+            role_id: true,
+          },
+        },
+        user_identifier: {
+          where: {
+            type: 'email',
+          },
+          select: {
+            value: true,
+          },
+          take: 1,
+        },
+      },
+      skip: (safePage - 1) * pageSize,
+      take: pageSize,
+      orderBy: [{ name: 'asc' }, { id: 'asc' }],
+    });
+
+    return {
+      data: users.map((candidateUser) => {
+        const userRoleIds = candidateUser.role_user.map(
+          (roleUser) => roleUser.role_id,
+        );
+        const hasRequiredRoles = this.userHasRequiredRolesForDashboard(
+          dashboardRoleRequirements,
+          userRoleIds,
+        );
+
+        return {
+          id: candidateUser.id,
+          name: candidateUser.name,
+          email: candidateUser.user_identifier[0]?.value ?? null,
+          hasRequiredRoles,
+          accessStatus: hasRequiredRoles ? 'allowed' : 'missing-roles',
+        };
+      }),
+      total,
+      page: safePage,
+      pageSize,
+      lastPage,
+      prev: safePage > 1 ? safePage - 1 : null,
+      next: safePage < lastPage ? safePage + 1 : null,
+    };
+  }
+
+  async shareDashboard(
+    userId: number,
+    slug: string,
+    sharedUserIds: number[] | undefined,
+    sharedUserId: number | undefined,
+    locale: string,
+  ) {
+    const requestedIds = Array.from(
+      new Set(
+        [
+          ...(Array.isArray(sharedUserIds) ? sharedUserIds : []),
+          ...(sharedUserId !== undefined ? [sharedUserId] : []),
+        ]
+          .map((value) => Number(value))
+          .filter((value) => Number.isInteger(value) && value > 0),
+      ),
+    );
+
+    if (requestedIds.length === 0) {
+      throw new BadRequestException(
+        getLocaleText('validation.fieldRequired', locale, 'User is required.'),
+      );
+    }
+
+    const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+    const sanitizedUserIds = requestedIds.filter((candidateUserId) => candidateUserId !== userId);
+
+    if (sanitizedUserIds.length === 0) {
+      throw new BadRequestException(
+        getLocaleText(
+          'validation.invalidValue',
+          locale,
+          'You already have access to this dashboard.',
+        ),
+      );
+    }
+
+    const targetUsers = await this.prismaService.user.findMany({
+      where: {
+        id: {
+          in: sanitizedUserIds,
+        },
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    if (targetUsers.length !== sanitizedUserIds.length) {
+      throw new BadRequestException(
+        getLocaleText('userNotFound', locale, 'User not found.'),
+      );
+    }
+
+    const existingShares = await this.prismaService.dashboard_user.findMany({
+      where: {
+        dashboard_id: dashboardUser.dashboard_id,
+        user_id: {
+          in: sanitizedUserIds,
+        },
+      },
+      select: {
+        user_id: true,
+      },
+    });
+
+    const alreadySharedUserIds = existingShares.map((item) => item.user_id);
+    const alreadySharedSet = new Set(alreadySharedUserIds);
+    const newUserIds = sanitizedUserIds.filter(
+      (candidateUserId) => !alreadySharedSet.has(candidateUserId),
+    );
+
+    if (newUserIds.length > 0) {
+      await this.prismaService.dashboard_user.createMany({
+        data: newUserIds.map((candidateUserId) => ({
+          dashboard_id: dashboardUser.dashboard_id,
+          user_id: candidateUserId,
+          is_home: false,
+        })),
+      });
+    }
+
+    return {
+      success: true,
+      sharedCount: newUserIds.length,
+      sharedUserIds: newUserIds,
+      alreadySharedUserIds,
+    };
+  }
+
+  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);