@hed-hog/core 0.0.299 → 0.0.301

package/dist/dashboard/dashboard-core/dashboard-core.service.js

@@ -430,6 +430,170 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
         }
         return value.map((provider) => String(provider).toLowerCase());
     }
+    slugifyDashboardName(value) {
+        const normalized = value
+            .normalize('NFD')
+            .replace(/[\u0300-\u036f]/g, '')
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '');
+        return normalized || `dashboard-${Date.now()}`;
+    }
+    getDashboardDisplayName(dashboard) {
+        var _a, _b;
+        return ((_b = (_a = dashboard.dashboard_locale) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.name) || dashboard.slug;
+    }
+    async buildUniqueDashboardSlug(baseSlug) {
+        let slug = baseSlug;
+        let suffix = 2;
+        while (await this.prismaService.dashboard.findFirst({
+            where: { slug },
+            select: { id: true },
+        })) {
+            slug = `${baseSlug}-${suffix}`;
+            suffix += 1;
+        }
+        return slug;
+    }
+    async getDashboardUserOrThrow(userId, slug, locale) {
+        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 common_1.ForbiddenException((0, api_locale_1.getLocaleText)('dashboardNotFound', locale, 'Dashboard not found.'));
+        }
+        return dashboardUser;
+    }
+    async getUserRoleIds(userId) {
+        const roleUsers = await this.prismaService.role_user.findMany({
+            where: { user_id: userId },
+            select: { role_id: true },
+        });
+        return roleUsers.map((roleUser) => roleUser.role_id);
+    }
+    async getDashboardComponentRoleRequirements(dashboardId) {
+        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();
+        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());
+    }
+    userHasRequiredRolesForDashboard(componentRoleRequirements, userRoleIds) {
+        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)));
+    }
+    async getDashboardRoleAccessState(dashboardId, userId) {
+        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',
+        };
+    }
+    async assertDashboardRoleAccess(dashboardId, userId) {
+        const { hasRequiredRoles } = await this.getDashboardRoleAccessState(dashboardId, userId);
+        if (!hasRequiredRoles) {
+            throw new common_1.ForbiddenException('Access denied to this dashboard');
+        }
+    }
+    async getAccessibleTemplateOrThrow(userId, templateSlug, locale) {
+        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: Object.assign({ 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 common_1.ForbiddenException((0, api_locale_1.getLocaleText)('dashboardNotFound', locale, 'Dashboard template not found.'));
+        }
+        return template;
+    }
     async getHome(userId, locale) {
         const user = await this.prismaService.user.findUnique({
             where: { id: userId },
@@ -712,6 +876,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
         if (!canAccess) {
             return [];
         }
+        await this.assertDashboardRoleAccess(dashboard.id, userId);
         const dashboardItems = await this.prismaService.dashboard_item.findMany({
             where: {
                 dashboard_id: dashboard.id,
@@ -771,26 +936,30 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
         if (!canAccess) {
             throw new common_1.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,
-                },
-            });
-            if (!dashboardItem) {
-                continue;
+        await this.assertDashboardRoleAccess(dashboard.id, userId);
+        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 };
     }
@@ -812,6 +981,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
         if (!canAccess) {
             throw new common_1.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 },
@@ -927,6 +1097,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
         if (!canAccess) {
             throw new common_1.ForbiddenException('Access denied to this dashboard');
         }
+        await this.assertDashboardRoleAccess(dashboard.id, userId);
         const parsedWidgetId = Number(widgetId.replace(/^widget-/, ''));
         if (!Number.isInteger(parsedWidgetId) || parsedWidgetId <= 0) {
             throw new common_1.BadRequestException('Invalid widget id');
@@ -975,9 +1146,18 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
                 user_id: userId,
             },
         });
-        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,
@@ -988,6 +1168,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
         };
     }
     async getUserDashboards(userId, locale) {
+        await this.getHome(userId, locale);
         const dashboardUsers = await this.prismaService.dashboard_user.findMany({
             where: { user_id: userId },
             include: {
@@ -1003,6 +1184,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
                     },
                 },
             },
+            orderBy: [{ is_home: 'desc' }, { id: 'asc' }],
         });
         const uniqueByDashboardId = new Map();
         for (const dashboardUser of dashboardUsers) {
@@ -1013,9 +1195,461 @@ let DashboardCoreService = DashboardCoreService_1 = 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, locale) {
+        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: Object.assign({ 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, data, locale) {
+        var _a, _b, _c, _d;
+        const templateSlug = this.toNullableString(data === null || data === void 0 ? void 0 : data.templateSlug);
+        const template = templateSlug
+            ? await this.getAccessibleTemplateOrThrow(userId, templateSlug, locale)
+            : null;
+        const templateName = template ? this.getDashboardDisplayName(template) : null;
+        const name = this.toNullableString(data === null || data === void 0 ? void 0 : data.name) || templateName;
+        if (!name) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('validation.fieldRequired', locale, 'Dashboard name is required.'));
+        }
+        const requestedSlug = this.toNullableString(data === null || data === void 0 ? void 0 : data.slug);
+        const baseSlug = this.slugifyDashboardName(requestedSlug || name);
+        const slug = await this.buildUniqueDashboardSlug(baseSlug);
+        const icon = (data === null || data === void 0 ? void 0 : data.icon) === undefined
+            ? (_a = template === null || template === void 0 ? void 0 : template.icon) !== null && _a !== void 0 ? _a : null
+            : (_c = (_b = this.toNullableString(data === null || data === void 0 ? void 0 : data.icon)) !== null && _b !== void 0 ? _b : template === null || template === void 0 ? void 0 : template.icon) !== null && _c !== void 0 ? _c : 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 ((_d = template === null || template === void 0 ? void 0 : template.dashboard_item) === null || _d === void 0 ? void 0 : _d.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, slug, data, locale) {
+        var _a, _b;
+        const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+        const name = this.toNullableString(data === null || data === void 0 ? void 0 : data.name);
+        const normalizedIcon = (data === null || data === void 0 ? void 0 : data.icon) === undefined ? undefined : this.toNullableString(data === null || data === void 0 ? void 0 : data.icon);
+        if (!name && (data === null || data === void 0 ? void 0 : data.icon) === undefined) {
+            throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('validation.fieldRequired', locale, 'Dashboard name or icon is required.'));
+        }
+        if ((data === null || data === void 0 ? void 0 : data.icon) !== undefined) {
+            await this.prismaService.dashboard.update({
+                where: { id: dashboardUser.dashboard_id },
+                data: {
+                    icon: normalizedIcon !== null && normalizedIcon !== void 0 ? normalizedIcon : null,
+                },
+            });
+        }
+        if (name) {
+            const localeRecord = await this.prismaService.locale.findFirst({
+                where: { code: locale },
+                select: { id: true },
+            });
+            if (!localeRecord) {
+                throw new common_1.BadRequestException((0, api_locale_1.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: (_b = (_a = updatedDashboard === null || updatedDashboard === void 0 ? void 0 : updatedDashboard.icon) !== null && _a !== void 0 ? _a : normalizedIcon) !== null && _b !== void 0 ? _b : null,
+        };
+    }
+    async setHomeDashboard(userId, slug, locale) {
+        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, slug, locale) {
+        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) => {
+            var _a, _b;
+            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: (_b = (_a = sharedDashboardUser.user.user_identifier[0]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : null,
+                isCurrentUser: sharedDashboardUser.user.id === userId,
+                isHome: sharedDashboardUser.is_home,
+                hasRequiredRoles,
+                accessStatus: hasRequiredRoles ? 'allowed' : 'missing-roles',
+            };
+        });
+    }
+    async getShareableUsers(userId, slug, options, locale) {
+        var _a, _b;
+        const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+        const normalizedSearch = this.toNullableString(options === null || options === void 0 ? void 0 : options.search);
+        const requestedPage = Number.parseInt(String((_a = options === null || options === void 0 ? void 0 : options.page) !== null && _a !== void 0 ? _a : '1'), 10);
+        const requestedPageSize = Number.parseInt(String((_b = options === null || options === void 0 ? void 0 : options.pageSize) !== null && _b !== void 0 ? _b : '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 = Object.assign({ 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',
+                                },
+                            },
+                        },
+                    },
+                ],
+            }
+            : {}));
+        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) => {
+                var _a, _b;
+                const userRoleIds = candidateUser.role_user.map((roleUser) => roleUser.role_id);
+                const hasRequiredRoles = this.userHasRequiredRolesForDashboard(dashboardRoleRequirements, userRoleIds);
+                return {
+                    id: candidateUser.id,
+                    name: candidateUser.name,
+                    email: (_b = (_a = candidateUser.user_identifier[0]) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : 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, slug, sharedUserIds, sharedUserId, locale) {
+        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 common_1.BadRequestException((0, api_locale_1.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 common_1.BadRequestException((0, api_locale_1.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 common_1.BadRequestException((0, api_locale_1.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, slug, sharedUserId, locale) {
+        const dashboardUser = await this.getDashboardUserOrThrow(userId, slug, locale);
+        if (sharedUserId === userId) {
+            throw new common_1.BadRequestException((0, api_locale_1.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, slug, locale) {
+        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) {
         const now = new Date();
         const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);