@hed-hog/core 0.0.297 → 0.0.299

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

@@ -8,14 +8,427 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var DashboardCoreService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DashboardCoreService = void 0;
 const api_locale_1 = require("@hed-hog/api-locale");
 const api_prisma_1 = require("@hed-hog/api-prisma");
 const common_1 = require("@nestjs/common");
-let DashboardCoreService = class DashboardCoreService {
-    constructor(prismaService) {
+const setting_service_1 = require("../../setting/setting.service");
+const MAIL_PROVIDER_REQUIREMENTS = {
+    SMTP: ['mail-from', 'mail-smtp-host', 'mail-smtp-port', 'mail-client-secret'],
+    GMAIL: [
+        'mail-from',
+        'mail-gmail-client-id',
+        'mail-gmail-client-secret',
+        'mail-gmail-refresh-token',
+    ],
+    SES: [
+        'mail-from',
+        'mail-aws-access-key-id',
+        'mail-aws-secret-access-key',
+        'mail-aws-region',
+    ],
+};
+const MAIL_PROVIDER_LABELS = {
+    SMTP: 'SMTP',
+    GMAIL: 'Gmail',
+    SES: 'Amazon SES',
+};
+const OAUTH_PROVIDER_DEFINITIONS = [
+    {
+        id: 'google',
+        label: 'Google',
+        requiredKeys: ['google_client_id', 'google_client_secret', 'url'],
+        scopeKey: 'google_scopes',
+    },
+    {
+        id: 'facebook',
+        label: 'Facebook',
+        requiredKeys: ['facebook_client_id', 'facebook_client_secret', 'url'],
+        scopeKey: 'facebook_scopes',
+    },
+    {
+        id: 'github',
+        label: 'GitHub',
+        requiredKeys: ['github_client_id', 'github_client_secret', 'api-url'],
+        scopeKey: 'github_scopes',
+    },
+    {
+        id: 'microsoft',
+        label: 'Microsoft',
+        requiredKeys: ['microsoft_client_id', 'microsoft_client_secret', 'url'],
+        scopeKey: 'microsoft_scopes',
+    },
+    {
+        id: 'microsoft_entra_id',
+        label: 'Microsoft Entra ID',
+        requiredKeys: [
+            'microsoft_entra_id_client_id',
+            'microsoft_entra_id_client_secret',
+            'microsoft_entra_id_tenant_id',
+            'url',
+        ],
+        scopeKey: 'microsoft_entra_id_scopes',
+    },
+];
+const LOCALE_SETTING_KEYS = ['date-format', 'time-format', 'timezone'];
+const MAIL_SETTING_KEYS = [
+    'mail-provider',
+    'mail-from',
+    'mail-gmail-client-id',
+    'mail-gmail-client-secret',
+    'mail-gmail-refresh-token',
+    'mail-smtp-host',
+    'mail-smtp-port',
+    'mail-smtp-secure',
+    'mail-client-secret',
+    'mail-aws-access-key-id',
+    'mail-aws-secret-access-key',
+    'mail-aws-region',
+];
+const OAUTH_SETTING_KEYS = [
+    'providers',
+    'url',
+    'api-url',
+    'google_client_id',
+    'google_client_secret',
+    'google_scopes',
+    'facebook_client_id',
+    'facebook_client_secret',
+    'facebook_scopes',
+    'github_client_id',
+    'github_client_secret',
+    'github_scopes',
+    'microsoft_client_id',
+    'microsoft_client_secret',
+    'microsoft_scopes',
+    'microsoft_entra_id_client_id',
+    'microsoft_entra_id_client_secret',
+    'microsoft_entra_id_tenant_id',
+    'microsoft_entra_id_scopes',
+];
+const THEME_SETTING_KEYS = [
+    'system-name',
+    'system-slogan',
+    'icon-url',
+    'image-url',
+    'theme-mode',
+    'theme-font',
+    'theme-text-size',
+    'theme-radius',
+    'theme-primary-light',
+    'theme-primary-foreground-light',
+    'theme-secondary-light',
+    'theme-secondary-foreground-light',
+    'theme-accent-light',
+    'theme-accent-foreground-light',
+    'theme-muted-light',
+    'theme-muted-foreground-light',
+    'theme-background-light',
+    'theme-background-foreground-light',
+    'theme-card-light',
+    'theme-card-foreground-light',
+    'theme-primary-dark',
+    'theme-primary-foreground-dark',
+    'theme-secondary-dark',
+    'theme-secondary-foreground-dark',
+    'theme-accent-dark',
+    'theme-accent-foreground-dark',
+    'theme-muted-dark',
+    'theme-muted-foreground-dark',
+    'theme-background-dark',
+    'theme-background-foreground-dark',
+    'theme-card-dark',
+    'theme-card-foreground-dark',
+];
+let DashboardCoreService = DashboardCoreService_1 = class DashboardCoreService {
+    constructor(prismaService, settingService) {
         this.prismaService = prismaService;
+        this.settingService = settingService;
+        this.logger = new common_1.Logger(DashboardCoreService_1.name);
+    }
+    async getConfigOverview() {
+        const [localeConfig, mailConfig, oauthConfig, storageConfig, themeConfig] = await Promise.all([
+            this.getLocaleConfigOverview(),
+            this.getMailConfigOverview(),
+            this.getOAuthConfigOverview(),
+            this.getStorageConfigOverview(),
+            this.getThemeConfigOverview(),
+        ]);
+        return {
+            localeConfig,
+            mailConfig,
+            oauthConfig,
+            storageConfig,
+            themeConfig,
+        };
+    }
+    async getLocaleConfigOverview() {
+        const [settings, locales] = await Promise.all([
+            this.settingService.getSettingValues([...LOCALE_SETTING_KEYS]),
+            this.prismaService.locale.findMany({
+                orderBy: [{ enabled: 'desc' }, { code: 'asc' }],
+                select: {
+                    id: true,
+                    code: true,
+                    region: true,
+                    name: true,
+                    enabled: true,
+                },
+            }),
+        ]);
+        const enabledLocaleCount = locales.filter((locale) => locale.enabled).length;
+        const disabledLocaleCount = locales.length - enabledLocaleCount;
+        return {
+            status: {
+                isConfigured: enabledLocaleCount > 0 &&
+                    this.hasConfigValue(settings['date-format']) &&
+                    this.hasConfigValue(settings['time-format']) &&
+                    this.hasConfigValue(settings['timezone']),
+                enabledLocaleCount,
+                disabledLocaleCount,
+            },
+            settings: {
+                dateFormat: this.toNullableString(settings['date-format']),
+                timeFormat: this.toNullableString(settings['time-format']),
+                timezone: this.toNullableString(settings['timezone']),
+            },
+            locales,
+        };
+    }
+    async getMailConfigOverview() {
+        var _a;
+        const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+        const [settings, templateCount, sentCount, sentLast30Days] = await Promise.all([
+            this.settingService.getSettingValues([...MAIL_SETTING_KEYS]),
+            this.prismaService.mail.count(),
+            this.prismaService.mail_sent.count(),
+            this.prismaService.mail_sent.count({
+                where: {
+                    created_at: {
+                        gte: thirtyDaysAgo,
+                    },
+                },
+            }),
+        ]);
+        const selectedProvider = this.toNullableUppercaseString(settings['mail-provider']);
+        const providers = Object.entries(MAIL_PROVIDER_REQUIREMENTS).map(([providerId, requiredKeys]) => {
+            var _a;
+            const missingKeys = this.getMissingSettingKeys(settings, requiredKeys);
+            return {
+                id: providerId,
+                label: (_a = MAIL_PROVIDER_LABELS[providerId]) !== null && _a !== void 0 ? _a : providerId,
+                selected: providerId === selectedProvider,
+                configured: missingKeys.length === 0,
+                missingKeys,
+            };
+        });
+        const configuredProvider = providers.find((provider) => provider.id === selectedProvider && provider.configured);
+        return {
+            status: {
+                isConfigured: configuredProvider !== undefined,
+                selectedProvider,
+                configuredProvider: (_a = configuredProvider === null || configuredProvider === void 0 ? void 0 : configuredProvider.id) !== null && _a !== void 0 ? _a : null,
+            },
+            sender: {
+                from: this.toNullableString(settings['mail-from']),
+            },
+            metrics: {
+                templateCount,
+                sentCount,
+                sentLast30Days,
+            },
+            providers,
+        };
+    }
+    async getOAuthConfigOverview() {
+        const [settings, connectedAccounts] = await Promise.all([
+            this.settingService.getSettingValues([...OAUTH_SETTING_KEYS]),
+            this.prismaService.user_account.groupBy({
+                by: ['provider'],
+                _count: {
+                    _all: true,
+                },
+            }),
+        ]);
+        const enabledProviders = this.normalizeProviderList(settings['providers']);
+        const connectedAccountsByProvider = new Map(connectedAccounts.map((entry) => [String(entry.provider), entry._count._all]));
+        const providers = OAUTH_PROVIDER_DEFINITIONS.map((provider) => {
+            var _a;
+            const missingKeys = this.getMissingSettingKeys(settings, provider.requiredKeys);
+            const scopes = Array.isArray(settings[provider.scopeKey])
+                ? settings[provider.scopeKey]
+                : [];
+            return {
+                id: provider.id,
+                label: provider.label,
+                enabled: enabledProviders.includes(provider.id),
+                configured: missingKeys.length === 0,
+                missingKeys,
+                scopesCount: scopes.length,
+                connectedUsers: (_a = connectedAccountsByProvider.get(provider.id)) !== null && _a !== void 0 ? _a : 0,
+            };
+        });
+        return {
+            status: {
+                isConfigured: providers.some((provider) => provider.enabled && provider.configured),
+                enabledProviderCount: providers.filter((provider) => provider.enabled).length,
+                configuredProviderCount: providers.filter((provider) => provider.configured).length,
+                connectedAccountCount: providers.reduce((total, provider) => total + provider.connectedUsers, 0),
+            },
+            providers,
+        };
+    }
+    async getStorageConfigOverview() {
+        var _a, _b;
+        const profiles = await this.prismaService.storage_profile.findMany({
+            where: {
+                deleted_at: null,
+            },
+            orderBy: [{ is_default: 'desc' }, { is_active: 'desc' }, { name: 'asc' }],
+            select: {
+                id: true,
+                name: true,
+                provider_type: true,
+                bucket_name: true,
+                region: true,
+                endpoint_url: true,
+                base_path: true,
+                path_template: true,
+                force_path_style: true,
+                is_default: true,
+                is_active: true,
+                test_status: true,
+                last_tested_at: true,
+                updated_at: true,
+            },
+        });
+        const providerMap = new Map();
+        profiles.forEach((profile) => {
+            var _a;
+            const providerType = String(profile.provider_type);
+            const current = (_a = providerMap.get(providerType)) !== null && _a !== void 0 ? _a : {
+                providerType,
+                total: 0,
+                active: 0,
+                defaults: 0,
+            };
+            current.total += 1;
+            current.active += profile.is_active ? 1 : 0;
+            current.defaults += profile.is_default ? 1 : 0;
+            providerMap.set(providerType, current);
+        });
+        const activeProfiles = profiles.filter((profile) => profile.is_active).length;
+        const defaultProfile = (_a = profiles.find((profile) => profile.is_default)) !== null && _a !== void 0 ? _a : null;
+        return {
+            status: {
+                isConfigured: activeProfiles > 0,
+                totalProfiles: profiles.length,
+                activeProfiles,
+                defaultProfileId: (_b = defaultProfile === null || defaultProfile === void 0 ? void 0 : defaultProfile.id) !== null && _b !== void 0 ? _b : null,
+            },
+            providers: Array.from(providerMap.values()),
+            profiles: profiles.map((profile) => ({
+                id: profile.id,
+                name: profile.name,
+                providerType: String(profile.provider_type),
+                bucketName: profile.bucket_name,
+                region: profile.region,
+                endpointUrl: profile.endpoint_url,
+                basePath: profile.base_path,
+                pathTemplate: profile.path_template,
+                forcePathStyle: profile.force_path_style,
+                isDefault: profile.is_default,
+                isActive: profile.is_active,
+                testStatus: String(profile.test_status),
+                lastTestedAt: profile.last_tested_at,
+                updatedAt: profile.updated_at,
+            })),
+        };
+    }
+    async getThemeConfigOverview() {
+        const settings = await this.settingService.getSettingValues([...THEME_SETTING_KEYS]);
+        const configuredTokenCount = THEME_SETTING_KEYS.filter((key) => this.hasConfigValue(settings[key])).length;
+        return {
+            status: {
+                isConfigured: this.hasConfigValue(settings['system-name']) ||
+                    this.hasConfigValue(settings['theme-primary-light']) ||
+                    this.hasConfigValue(settings['theme-primary-dark']),
+                configuredTokenCount,
+            },
+            branding: {
+                systemName: this.toNullableString(settings['system-name']),
+                systemSlogan: this.toNullableString(settings['system-slogan']),
+                iconUrl: this.toNullableString(settings['icon-url']),
+                imageUrl: this.toNullableString(settings['image-url']),
+            },
+            presentation: {
+                mode: this.toNullableString(settings['theme-mode']),
+                font: this.toNullableString(settings['theme-font']),
+                textSize: this.toNullableString(settings['theme-text-size']),
+                radius: this.toNullableString(settings['theme-radius']),
+            },
+            palette: {
+                light: {
+                    primary: this.toNullableString(settings['theme-primary-light']),
+                    primaryForeground: this.toNullableString(settings['theme-primary-foreground-light']),
+                    secondary: this.toNullableString(settings['theme-secondary-light']),
+                    secondaryForeground: this.toNullableString(settings['theme-secondary-foreground-light']),
+                    accent: this.toNullableString(settings['theme-accent-light']),
+                    accentForeground: this.toNullableString(settings['theme-accent-foreground-light']),
+                    muted: this.toNullableString(settings['theme-muted-light']),
+                    mutedForeground: this.toNullableString(settings['theme-muted-foreground-light']),
+                    background: this.toNullableString(settings['theme-background-light']),
+                    backgroundForeground: this.toNullableString(settings['theme-background-foreground-light']),
+                    card: this.toNullableString(settings['theme-card-light']),
+                    cardForeground: this.toNullableString(settings['theme-card-foreground-light']),
+                },
+                dark: {
+                    primary: this.toNullableString(settings['theme-primary-dark']),
+                    primaryForeground: this.toNullableString(settings['theme-primary-foreground-dark']),
+                    secondary: this.toNullableString(settings['theme-secondary-dark']),
+                    secondaryForeground: this.toNullableString(settings['theme-secondary-foreground-dark']),
+                    accent: this.toNullableString(settings['theme-accent-dark']),
+                    accentForeground: this.toNullableString(settings['theme-accent-foreground-dark']),
+                    muted: this.toNullableString(settings['theme-muted-dark']),
+                    mutedForeground: this.toNullableString(settings['theme-muted-foreground-dark']),
+                    background: this.toNullableString(settings['theme-background-dark']),
+                    backgroundForeground: this.toNullableString(settings['theme-background-foreground-dark']),
+                    card: this.toNullableString(settings['theme-card-dark']),
+                    cardForeground: this.toNullableString(settings['theme-card-foreground-dark']),
+                },
+            },
+        };
+    }
+    getMissingSettingKeys(settings, requiredKeys) {
+        return requiredKeys.filter((key) => !this.hasConfigValue(settings[key]));
+    }
+    hasConfigValue(value) {
+        if (Array.isArray(value)) {
+            return value.length > 0;
+        }
+        if (typeof value === 'string') {
+            return value.trim().length > 0;
+        }
+        return value !== null && value !== undefined;
+    }
+    toNullableString(value) {
+        if (typeof value !== 'string') {
+            return value === null || value === undefined ? null : String(value);
+        }
+        const normalized = value.trim();
+        return normalized.length > 0 ? normalized : null;
+    }
+    toNullableUppercaseString(value) {
+        const normalized = this.toNullableString(value);
+        return normalized ? normalized.toUpperCase() : null;
+    }
+    normalizeProviderList(value) {
+        if (!Array.isArray(value)) {
+            return [];
+        }
+        return value.map((provider) => String(provider).toLowerCase());
     }
     async getHome(userId, locale) {
         const user = await this.prismaService.user.findUnique({
@@ -326,6 +739,7 @@ let DashboardCoreService = 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,
@@ -398,8 +812,44 @@ let DashboardCoreService = 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: {
@@ -411,7 +861,7 @@ let DashboardCoreService = 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: {
@@ -420,6 +870,16 @@ let DashboardCoreService = 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,
@@ -427,7 +887,7 @@ let DashboardCoreService = class DashboardCoreService {
                     width: component.width,
                     height: component.height,
                     x_axis: 0,
-                    y_axis: 0,
+                    y_axis: nextAvailableY,
                 },
             });
         }
@@ -436,6 +896,7 @@ let DashboardCoreService = 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,
@@ -450,7 +911,43 @@ let DashboardCoreService = 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;
@@ -739,10 +1236,121 @@ let DashboardCoreService = class DashboardCoreService {
             });
         });
     }
+    async getEmailNotificationStats(userId) {
+        var _a, _b;
+        const now = new Date();
+        const periodStart = new Date(now);
+        periodStart.setHours(0, 0, 0, 0);
+        periodStart.setDate(periodStart.getDate() - 13);
+        const periodEnd = new Date(now);
+        periodEnd.setHours(23, 59, 59, 999);
+        const toDateKey = (date) => {
+            const year = date.getFullYear();
+            const month = String(date.getMonth() + 1).padStart(2, '0');
+            const day = String(date.getDate()).padStart(2, '0');
+            return `${year}-${month}-${day}`;
+        };
+        try {
+            const [cardsRows, chartRows] = await Promise.all([
+                this.prismaService.$queryRaw `
+          SELECT
+            COUNT(*) FILTER (WHERE "status" IN ('received', 'read'))::bigint as received,
+            COUNT(*) FILTER (WHERE "status" = 'read')::bigint as read,
+            COUNT(*) FILTER (WHERE "status" = 'received' AND "read_at" IS NULL)::bigint as unread,
+            COUNT(*) FILTER (WHERE "status" = 'error')::bigint as error
+          FROM "mail_sent_user"
+          WHERE "user_id" = ${userId}
+            AND "created_at" >= ${periodStart}
+            AND "created_at" <= ${periodEnd}
+        `,
+                this.prismaService.$queryRaw `
+          SELECT
+            DATE("created_at") as date,
+            COUNT(*) FILTER (WHERE "status" IN ('received', 'read'))::bigint as received,
+            COUNT(*) FILTER (WHERE "status" = 'read')::bigint as read
+          FROM "mail_sent_user"
+          WHERE "user_id" = ${userId}
+            AND "created_at" >= ${periodStart}
+            AND "created_at" <= ${periodEnd}
+          GROUP BY DATE("created_at")
+          ORDER BY date ASC
+        `,
+            ]);
+            const cards = (_a = cardsRows[0]) !== null && _a !== void 0 ? _a : {
+                received: BigInt(0),
+                read: BigInt(0),
+                unread: BigInt(0),
+                error: BigInt(0),
+            };
+            const chartMap = new Map();
+            for (const row of chartRows) {
+                const rowDate = new Date(row.date);
+                rowDate.setHours(0, 0, 0, 0);
+                const key = toDateKey(rowDate);
+                chartMap.set(key, {
+                    received: Number(row.received),
+                    read: Number(row.read),
+                });
+            }
+            const dateFormatter = new Intl.DateTimeFormat('pt-BR', {
+                day: '2-digit',
+                month: '2-digit',
+            });
+            const chart = [];
+            for (let i = 13; i >= 0; i--) {
+                const day = new Date(now);
+                day.setDate(day.getDate() - i);
+                day.setHours(0, 0, 0, 0);
+                const key = toDateKey(day);
+                const values = (_b = chartMap.get(key)) !== null && _b !== void 0 ? _b : { received: 0, read: 0 };
+                chart.push({
+                    date: dateFormatter.format(day),
+                    received: values.received,
+                    read: values.read,
+                });
+            }
+            return {
+                cards: {
+                    received: Number(cards.received),
+                    read: Number(cards.read),
+                    unread: Number(cards.unread),
+                    error: Number(cards.error),
+                },
+                chart,
+            };
+        }
+        catch (error) {
+            this.logger.error('Error loading email notification stats:', error);
+            const dateFormatter = new Intl.DateTimeFormat('pt-BR', {
+                day: '2-digit',
+                month: '2-digit',
+            });
+            const chart = [];
+            for (let i = 13; i >= 0; i--) {
+                const day = new Date(now);
+                day.setDate(day.getDate() - i);
+                chart.push({
+                    date: dateFormatter.format(day),
+                    received: 0,
+                    read: 0,
+                });
+            }
+            return {
+                cards: {
+                    received: 0,
+                    read: 0,
+                    unread: 0,
+                    error: 0,
+                },
+                chart,
+            };
+        }
+    }
     async getWidgetsData(userId, locale) {
-        const [accountSecurity, activityTimeline, loginHistory, profile, quickStats, userRoles, userSessions] = await Promise.all([
+        const [accountSecurity, activityTimeline, emailNotifications, loginHistory, profile, quickStats, userRoles, userSessions] = await Promise.all([
             this.getAccountSecurity(userId),
             this.getActivityTimeline(userId),
+            this.getEmailNotificationStats(userId),
             this.getLoginHistory(userId),
             this.getProfile(userId),
             this.getQuickStats(userId),
@@ -752,6 +1360,7 @@ let DashboardCoreService = class DashboardCoreService {
         return {
             accountSecurity,
             activityTimeline,
+            emailNotifications,
             loginHistory,
             profile,
             quickStats,
@@ -780,8 +1389,9 @@ let DashboardCoreService = class DashboardCoreService {
     }
 };
 exports.DashboardCoreService = DashboardCoreService;
-exports.DashboardCoreService = DashboardCoreService = __decorate([
+exports.DashboardCoreService = DashboardCoreService = DashboardCoreService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [api_prisma_1.PrismaService])
+    __metadata("design:paramtypes", [api_prisma_1.PrismaService,
+        setting_service_1.SettingService])
 ], DashboardCoreService);
 //# sourceMappingURL=dashboard-core.service.js.map