@hed-hog/core 0.0.298 → 0.0.300

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

@@ -430,6 +430,115 @@ 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 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 },
@@ -739,6 +848,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
                 i: `widget-${item.id}`,
                 component_id: item.component_id,
                 slug: component.slug,
+                library_slug: component.library_slug,
                 name: (locale === null || locale === void 0 ? void 0 : locale.name) || component.slug,
                 description: (locale === null || locale === void 0 ? void 0 : locale.description) || '',
                 x: item.x_axis,
@@ -770,26 +880,29 @@ 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;
+        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 };
     }
@@ -811,8 +924,44 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
         if (!canAccess) {
             throw new common_1.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 common_1.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: {
@@ -824,7 +973,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
             },
         });
         if (!component) {
-            throw new Error(`Component with slug '${componentSlug}' not found`);
+            throw new common_1.ForbiddenException('Access denied to this component');
         }
         let dashboardItem = await this.prismaService.dashboard_item.findFirst({
             where: {
@@ -833,6 +982,16 @@ let DashboardCoreService = DashboardCoreService_1 = 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,
@@ -840,7 +999,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
                     width: component.width,
                     height: component.height,
                     x_axis: 0,
-                    y_axis: 0,
+                    y_axis: nextAvailableY,
                 },
             });
         }
@@ -849,6 +1008,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
             i: `widget-${dashboardItem.id}`,
             component_id: component.id,
             slug: component.slug,
+            library_slug: component.library_slug,
             name: (locale === null || locale === void 0 ? void 0 : locale.name) || component.slug,
             description: (locale === null || locale === void 0 ? void 0 : locale.description) || '',
             x: dashboardItem.x_axis,
@@ -863,7 +1023,43 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
         };
     }
     async removeWidgetFromUserDashboard(userId, slug, widgetId) {
-        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 common_1.ForbiddenException('Access denied to this dashboard');
+        }
+        const parsedWidgetId = Number(widgetId.replace(/^widget-/, ''));
+        if (!Number.isInteger(parsedWidgetId) || parsedWidgetId <= 0) {
+            throw new common_1.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 common_1.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, slug, locale) {
         var _a;
@@ -904,6 +1100,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: {
@@ -919,6 +1116,7 @@ let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
                     },
                 },
             },
+            orderBy: [{ is_home: 'desc' }, { id: 'asc' }],
         });
         const uniqueByDashboardId = new Map();
         for (const dashboardUser of dashboardUsers) {
@@ -929,9 +1127,402 @@ 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 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) => {
+            var _a, _b;
+            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,
+            });
+        });
+    }
+    async getShareableUsers(userId, slug, search, locale) {
+        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',
+                            },
+                        },
+                        {
+                            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) => {
+            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,
+            });
+        });
+    }
+    async shareDashboard(userId, slug, sharedUserId, locale) {
+        if (!sharedUserId || Number.isNaN(Number(sharedUserId))) {
+            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) {
+            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 },
+        });
+        if (!targetUser) {
+            throw new common_1.BadRequestException((0, api_locale_1.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, 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);