@hed-hog/core 0.0.300 → 0.0.302

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

@@ -487,6 +487,61 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
         });
         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
@@ -821,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,
@@ -880,6 +936,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 layoutUpdates = layout.flatMap((item) => {
             const itemId = Number.parseInt(item.i.replace('widget-', ''), 10);
             if (Number.isNaN(itemId)) {
@@ -924,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 },
@@ -1039,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');
@@ -1087,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,
@@ -1337,6 +1405,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
     }
     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,
@@ -1346,6 +1415,11 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
                     select: {
                         id: true,
                         name: true,
+                        role_user: {
+                            select: {
+                                role_id: true,
+                            },
+                        },
                         user_identifier: {
                             where: {
                                 type: 'email',
@@ -1364,55 +1438,78 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
         });
         return sharedUsers.map((sharedDashboardUser) => {
             var _a, _b;
-            return ({
+            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, search, locale) {
+    async getShareableUsers(userId, slug, options, locale) {
+        var _a, _b;
         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: Object.assign({ id: {
-                    notIn: existingUsers.map((item) => item.user_id),
-                } }, (normalizedSearch
-                ? {
-                    OR: [
-                        {
-                            name: {
-                                contains: normalizedSearch,
-                                mode: 'insensitive',
-                            },
+        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',
-                                    },
+                    },
+                    {
+                        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',
@@ -1423,57 +1520,87 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
                     take: 1,
                 },
             },
-            take: 20,
-            orderBy: {
-                id: 'desc',
-            },
-        });
-        return users.map((candidateUser) => {
-            var _a, _b;
-            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,
-            });
+            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, sharedUserId, locale) {
-        if (!sharedUserId || Number.isNaN(Number(sharedUserId))) {
+    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);
-        if (sharedUserId === userId) {
+        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 targetUser = await this.prismaService.user.findUnique({
-            where: { id: sharedUserId },
-            select: { id: true },
+        const targetUsers = await this.prismaService.user.findMany({
+            where: {
+                id: {
+                    in: sanitizedUserIds,
+                },
+            },
+            select: {
+                id: true,
+            },
         });
-        if (!targetUser) {
+        if (targetUsers.length !== sanitizedUserIds.length) {
             throw new common_1.BadRequestException((0, api_locale_1.getLocaleText)('userNotFound', locale, 'User not found.'));
         }
-        const existingShare = await this.prismaService.dashboard_user.findFirst({
+        const existingShares = await this.prismaService.dashboard_user.findMany({
             where: {
                 dashboard_id: dashboardUser.dashboard_id,
-                user_id: sharedUserId,
+                user_id: {
+                    in: sanitizedUserIds,
+                },
             },
-            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,
+            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) {