@hed-hog/core 0.0.297 → 0.0.299

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

@@ -1,10 +1,646 @@
 import { getLocaleText } from '@hed-hog/api-locale';
 import { PrismaService } from '@hed-hog/api-prisma';
-import { BadRequestException, ForbiddenException, Injectable } from '@nestjs/common';
+import { BadRequestException, ForbiddenException, Injectable, Logger } from '@nestjs/common';
+import { SettingService } from '../../setting/setting.service';
+
+type DashboardCoreConfigStatus = {
+  isConfigured: boolean;
+};
+
+type DashboardCoreLocaleConfigOverview = {
+  status: DashboardCoreConfigStatus & {
+    enabledLocaleCount: number;
+    disabledLocaleCount: number;
+  };
+  settings: {
+    dateFormat: string | null;
+    timeFormat: string | null;
+    timezone: string | null;
+  };
+  locales: Array<{
+    id: number;
+    code: string;
+    region: string;
+    name: string;
+    enabled: boolean;
+  }>;
+};
+
+type DashboardCoreMailProviderOverview = {
+  id: string;
+  label: string;
+  selected: boolean;
+  configured: boolean;
+  missingKeys: string[];
+};
+
+type DashboardCoreMailConfigOverview = {
+  status: DashboardCoreConfigStatus & {
+    selectedProvider: string | null;
+    configuredProvider: string | null;
+  };
+  sender: {
+    from: string | null;
+  };
+  metrics: {
+    templateCount: number;
+    sentCount: number;
+    sentLast30Days: number;
+  };
+  providers: DashboardCoreMailProviderOverview[];
+};
+
+type DashboardCoreOAuthProviderOverview = {
+  id: string;
+  label: string;
+  enabled: boolean;
+  configured: boolean;
+  missingKeys: string[];
+  scopesCount: number;
+  connectedUsers: number;
+};
+
+type DashboardCoreOAuthConfigOverview = {
+  status: DashboardCoreConfigStatus & {
+    enabledProviderCount: number;
+    configuredProviderCount: number;
+    connectedAccountCount: number;
+  };
+  providers: DashboardCoreOAuthProviderOverview[];
+};
+
+type DashboardCoreStorageConfigOverview = {
+  status: DashboardCoreConfigStatus & {
+    totalProfiles: number;
+    activeProfiles: number;
+    defaultProfileId: number | null;
+  };
+  providers: Array<{
+    providerType: string;
+    total: number;
+    active: number;
+    defaults: number;
+  }>;
+  profiles: Array<{
+    id: number;
+    name: string;
+    providerType: string;
+    bucketName: string;
+    region: string | null;
+    endpointUrl: string | null;
+    basePath: string | null;
+    pathTemplate: string | null;
+    forcePathStyle: boolean;
+    isDefault: boolean;
+    isActive: boolean;
+    testStatus: string;
+    lastTestedAt: Date | null;
+    updatedAt: Date;
+  }>;
+};
+
+type DashboardCoreThemePaletteMode = {
+  primary: string | null;
+  primaryForeground: string | null;
+  secondary: string | null;
+  secondaryForeground: string | null;
+  accent: string | null;
+  accentForeground: string | null;
+  muted: string | null;
+  mutedForeground: string | null;
+  background: string | null;
+  backgroundForeground: string | null;
+  card: string | null;
+  cardForeground: string | null;
+};
+
+type DashboardCoreThemeConfigOverview = {
+  status: DashboardCoreConfigStatus & {
+    configuredTokenCount: number;
+  };
+  branding: {
+    systemName: string | null;
+    systemSlogan: string | null;
+    iconUrl: string | null;
+    imageUrl: string | null;
+  };
+  presentation: {
+    mode: string | null;
+    font: string | null;
+    textSize: string | null;
+    radius: string | null;
+  };
+  palette: {
+    light: DashboardCoreThemePaletteMode;
+    dark: DashboardCoreThemePaletteMode;
+  };
+};
+
+export type DashboardCoreConfigOverview = {
+  localeConfig: DashboardCoreLocaleConfigOverview;
+  mailConfig: DashboardCoreMailConfigOverview;
+  oauthConfig: DashboardCoreOAuthConfigOverview;
+  storageConfig: DashboardCoreStorageConfigOverview;
+  themeConfig: DashboardCoreThemeConfigOverview;
+};
+
+const MAIL_PROVIDER_REQUIREMENTS: Record<string, string[]> = {
+  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: Record<string, string> = {
+  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',
+  },
+] as const;
+
+const LOCALE_SETTING_KEYS = ['date-format', 'time-format', 'timezone'] as const;
+
+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',
+] as const;
+
+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',
+] as const;
+
+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',
+] as const;
 
 @Injectable()
 export class DashboardCoreService {
-  constructor(private readonly prismaService: PrismaService) {}
+  private readonly logger = new Logger(DashboardCoreService.name);
+
+  constructor(
+    private readonly prismaService: PrismaService,
+    private readonly settingService: SettingService,
+  ) {}
+
+  async getConfigOverview(): Promise<DashboardCoreConfigOverview> {
+    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,
+    };
+  }
+
+  private async getLocaleConfigOverview(): Promise<DashboardCoreLocaleConfigOverview> {
+    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,
+    };
+  }
+
+  private async getMailConfigOverview(): Promise<DashboardCoreMailConfigOverview> {
+    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]) => {
+        const missingKeys = this.getMissingSettingKeys(settings, requiredKeys);
+
+        return {
+          id: providerId,
+          label: MAIL_PROVIDER_LABELS[providerId] ?? 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: configuredProvider?.id ?? null,
+      },
+      sender: {
+        from: this.toNullableString(settings['mail-from']),
+      },
+      metrics: {
+        templateCount,
+        sentCount,
+        sentLast30Days,
+      },
+      providers,
+    };
+  }
+
+  private async getOAuthConfigOverview(): Promise<DashboardCoreOAuthConfigOverview> {
+    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) => {
+      const missingKeys = this.getMissingSettingKeys(settings, provider.requiredKeys);
+      const scopes = Array.isArray(settings[provider.scopeKey])
+        ? (settings[provider.scopeKey] as unknown[])
+        : [];
+
+      return {
+        id: provider.id,
+        label: provider.label,
+        enabled: enabledProviders.includes(provider.id),
+        configured: missingKeys.length === 0,
+        missingKeys,
+        scopesCount: scopes.length,
+        connectedUsers: connectedAccountsByProvider.get(provider.id) ?? 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,
+    };
+  }
+
+  private async getStorageConfigOverview(): Promise<DashboardCoreStorageConfigOverview> {
+    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<
+      string,
+      { providerType: string; total: number; active: number; defaults: number }
+    >();
+
+    profiles.forEach((profile) => {
+      const providerType = String(profile.provider_type);
+      const current = providerMap.get(providerType) ?? {
+        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 = profiles.find((profile) => profile.is_default) ?? null;
+
+    return {
+      status: {
+        isConfigured: activeProfiles > 0,
+        totalProfiles: profiles.length,
+        activeProfiles,
+        defaultProfileId: defaultProfile?.id ?? 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,
+      })),
+    };
+  }
+
+  private async getThemeConfigOverview(): Promise<DashboardCoreThemeConfigOverview> {
+    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'],
+          ),
+        },
+      },
+    };
+  }
+
+  private getMissingSettingKeys(
+    settings: Record<string, unknown>,
+    requiredKeys: readonly string[],
+  ): string[] {
+    return requiredKeys.filter((key) => !this.hasConfigValue(settings[key]));
+  }
+
+  private hasConfigValue(value: unknown): boolean {
+    if (Array.isArray(value)) {
+      return value.length > 0;
+    }
+
+    if (typeof value === 'string') {
+      return value.trim().length > 0;
+    }
+
+    return value !== null && value !== undefined;
+  }
+
+  private toNullableString(value: unknown): string | null {
+    if (typeof value !== 'string') {
+      return value === null || value === undefined ? null : String(value);
+    }
+
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : null;
+  }
+
+  private toNullableUppercaseString(value: unknown): string | null {
+    const normalized = this.toNullableString(value);
+    return normalized ? normalized.toUpperCase() : null;
+  }
+
+  private normalizeProviderList(value: unknown): string[] {
+    if (!Array.isArray(value)) {
+      return [];
+    }
+
+    return value.map((provider) => String(provider).toLowerCase());
+  }
 
   async getHome(userId: number, locale: string) {
     const user = await this.prismaService.user.findUnique({
@@ -378,6 +1014,7 @@ export class DashboardCoreService {
         i: `widget-${item.id}`,
         component_id: item.component_id,
         slug: component.slug,
+        library_slug: component.library_slug,
         name: locale?.name || component.slug,
         description: locale?.description || '',
         x: item.x_axis,
@@ -477,8 +1114,50 @@ export class DashboardCoreService {
       throw new 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 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: {
@@ -491,7 +1170,7 @@ export class DashboardCoreService {
     });
 
     if (!component) {
-      throw new Error(`Component with slug '${componentSlug}' not found`);
+      throw new ForbiddenException('Access denied to this component');
     }
 
     let dashboardItem = await this.prismaService.dashboard_item.findFirst({
@@ -502,6 +1181,21 @@ export 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,
@@ -509,7 +1203,7 @@ export class DashboardCoreService {
           width: component.width,
           height: component.height,
           x_axis: 0,
-          y_axis: 0,
+          y_axis: nextAvailableY,
         },
       });
     }
@@ -520,6 +1214,7 @@ export class DashboardCoreService {
       i: `widget-${dashboardItem.id}`,
       component_id: component.id,
       slug: component.slug,
+      library_slug: component.library_slug,
       name: locale?.name || component.slug,
       description: locale?.description || '',
       x: dashboardItem.x_axis,
@@ -539,8 +1234,52 @@ export class DashboardCoreService {
     slug: string,
     widgetId: string,
   ) {
-    
-    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 ForbiddenException('Access denied to this dashboard');
+    }
+
+    const parsedWidgetId = Number(widgetId.replace(/^widget-/, ''));
+
+    if (!Number.isInteger(parsedWidgetId) || parsedWidgetId <= 0) {
+      throw new 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 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: number, slug: string, locale: string) {
@@ -864,11 +1603,137 @@ export class DashboardCoreService {
     }));
   }
 
+  async getEmailNotificationStats(userId: number) {
+    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: 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<
+          Array<{ received: bigint; read: bigint; unread: bigint; error: bigint }>
+        >`
+          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<Array<{ date: Date; received: bigint; read: bigint }>>`
+          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 = cardsRows[0] ?? {
+        received: BigInt(0),
+        read: BigInt(0),
+        unread: BigInt(0),
+        error: BigInt(0),
+      };
+
+      const chartMap = new Map<string, { received: number; read: number }>();
+      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: Array<{ date: string; received: number; read: number }> = [];
+      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 = chartMap.get(key) ?? { 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: Array<{ date: string; received: number; read: number }> = [];
+      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: number, locale: string) {
-    const [accountSecurity, activityTimeline, loginHistory, profile, quickStats, userRoles, userSessions] =
+    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),
@@ -879,6 +1744,7 @@ export class DashboardCoreService {
     return {
       accountSecurity,
       activityTimeline,
+      emailNotifications,
       loginHistory,
       profile,
       quickStats,