@hed-hog/core 0.0.169 → 0.0.171

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

@@ -27,68 +27,170 @@ export class DashboardCoreService {
 
   async getStatistics() {
     const now = new Date();
+    const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate());
     const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
-    const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
-    const totalUsers = await this.prismaService.user.count();
-    const recentUsers = await this.prismaService.user.count({
-      where: {
-        created_at: {
-          gte: sevenDaysAgo,
-        },
-      },
-    });
+    const twelveMonthsAgo = new Date(now.getFullYear() - 1, now.getMonth(), 1);
+    const currentMonthStart = new Date(now.getFullYear(), now.getMonth(), 1);
+    const lastMonthStart = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+    const lastMonthEnd = new Date(now.getFullYear(), now.getMonth(), 0, 23, 59, 59);
+
+    const [
+      sessionsTodayCount, 
+      activeUsersCount, 
+      emailsSentCount, 
+      rolesCount,
+      sessionsCurrentMonth,
+      usersCurrentMonth,
+      emailsCurrentMonth,
+      rolesCurrentMonth,
+      sessionsLastMonth,
+      usersLastMonth,
+      emailsLastMonth,
+      rolesLastMonth,
+    ] = await Promise.all([
+      this.prismaService.user_session.count({ where: { created_at: { gte: todayStart } } }),
+      this.prismaService.user.count(),
+      this.prismaService.mail_sent.count(),
+      this.prismaService.role.count(),
+      this.prismaService.user_session.count({ where: { created_at: { gte: currentMonthStart } } }),
+      this.prismaService.user.count({ where: { created_at: { gte: currentMonthStart } } }),
+      this.prismaService.mail_sent.count({ where: { created_at: { gte: currentMonthStart } } }),
+      this.prismaService.role.count({ where: { created_at: { gte: currentMonthStart } } }),
+      this.prismaService.user_session.count({ where: { created_at: { gte: lastMonthStart, lte: lastMonthEnd } } }),
+      this.prismaService.user.count({ where: { created_at: { gte: lastMonthStart, lte: lastMonthEnd } } }),
+      this.prismaService.mail_sent.count({ where: { created_at: { gte: lastMonthStart, lte: lastMonthEnd } } }),
+      this.prismaService.role.count({ where: { created_at: { gte: lastMonthStart, lte: lastMonthEnd } } }),
+    ]);
+
+    const calculateChange = (current: number, previous: number) => {
+      if (previous === 0) {
+        return current === 0 ? 0 : 100;
+      }
+      return Number((((current - previous) / previous) * 100).toFixed(1));
+    };
 
-    const activeUsers = await this.prismaService.user.count({
-      where: {
-        created_at: {
-          gte: thirtyDaysAgo,
-        },
-      },
-    });
+    const sessionsChange = calculateChange(sessionsCurrentMonth, sessionsLastMonth);
+    const usersChange = calculateChange(usersCurrentMonth, usersLastMonth);
+    const emailsChange = calculateChange(emailsCurrentMonth, emailsLastMonth);
+    const rolesChange = calculateChange(rolesCurrentMonth, rolesLastMonth);
 
-    const totalRoles = await this.prismaService.role.count();
-    const totalMenus = await this.prismaService.menu.count();
-    const totalRoutes = await this.prismaService.route.count();
-    const totalModules = await this.prismaService.dashboard_component.count();
-    const totalSettings = await this.prismaService.setting.count();
-    const totalContacts = await this.prismaService.person.count().catch(() => 0);
+    const emailsPerWeek = await this.prismaService.$queryRaw<
+      Array<{ day: Date; sent: bigint }>
+    >`
+      SELECT 
+        DATE("created_at") as day,
+        COUNT(*) as sent
+      FROM "mail_sent"
+      WHERE "created_at" >= ${sevenDaysAgo}
+      GROUP BY DATE("created_at")
+      ORDER BY day ASC
+    `;
 
-    return {
-      totalUsers,
-      recentUsers,
-      activeUsers,
-      totalRoles,
-      totalMenus,
-      totalRoutes,
-      totalModules,
-      totalSettings,
-      totalContacts,
-    };
-  }
+    const weekDays = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    const emailWeekData = emailsPerWeek.map((item) => {
+      const dayOfWeek = new Date(item.day).getDay();
+      return {
+        day: weekDays[dayOfWeek],
+        sent: Number(item.sent),
+      };
+    });
 
-  async getUserGrowth() {
-    const now = new Date();
-    const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
-    const usersByDay = await this.prismaService.$queryRaw<
-      Array<{ date: Date; count: bigint }>
+    const permissionDistribution = await this.prismaService.$queryRaw<
+      Array<{ name: string; value: bigint }>
     >`
-      SELECT DATE("created_at") as date, COUNT(*) as count
-      FROM "user"
-      WHERE "created_at" >= ${thirtyDaysAgo}
-      GROUP BY DATE("created_at")
-      ORDER BY date ASC
+      SELECT 
+        r.slug as name,
+        COUNT(ru.user_id) as value
+      FROM "role" r
+      LEFT JOIN "role_user" ru ON r.id = ru.role_id
+      GROUP BY r.id, r.slug
+      ORDER BY value DESC
     `;
 
-    return usersByDay.map((item) => ({
-      date: item.date,
-      count: Number(item.count),
+    const colors = ['#6366f1', '#10b981', '#f59e0b', '#8b5cf6', '#ec4899', '#14b8a6'];
+    const permissionsData = permissionDistribution.map((item, index) => ({
+      name: item.name,
+      value: Number(item.value),
+      color: colors[index % colors.length],
     }));
+
+    const sessionActivity = await this.prismaService.$queryRaw<
+      Array<{ hour: number; active: bigint; expired: bigint }>
+    >`
+      SELECT 
+        FLOOR(EXTRACT(HOUR FROM "created_at" AT TIME ZONE 'America/Sao_Paulo') / 2) * 2 as hour,
+        COUNT(CASE WHEN "expires_at" > NOW() THEN 1 END) as active,
+        COUNT(CASE WHEN "expires_at" <= NOW() THEN 1 END) as expired
+      FROM "user_session"
+      WHERE "created_at" >= ${todayStart}
+      GROUP BY FLOOR(EXTRACT(HOUR FROM "created_at" AT TIME ZONE 'America/Sao_Paulo') / 2)
+      ORDER BY hour ASC
+    `;
+
+    const sessionActivityData = [];
+    for (let h = 0; h < 24; h += 2) {
+      const found = sessionActivity.find((s) => Number(s.hour) === h);
+      sessionActivityData.push({
+        hour: `${h.toString().padStart(2, '0')}h`,
+        active: found ? Number(found.active) : 0,
+        expired: found ? Number(found.expired) : 0,
+      });
+    }
+
+    const userGrowth = await this.prismaService.$queryRaw<
+      Array<{ month: Date; users: bigint; sessions: bigint }>
+    >`
+      SELECT 
+        DATE_TRUNC('month', u."created_at") as month,
+        COUNT(DISTINCT u.id) as users,
+        COUNT(s.id) as sessions
+      FROM "user" u
+      LEFT JOIN "user_session" s ON u.id = s.user_id AND DATE_TRUNC('month', u."created_at") = DATE_TRUNC('month', s."created_at")
+      WHERE u."created_at" >= ${twelveMonthsAgo}
+      GROUP BY DATE_TRUNC('month', u."created_at")
+      ORDER BY month ASC
+    `;
+
+    const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const userGrowthData = userGrowth.map((item) => {
+      const monthIndex = new Date(item.month).getMonth() + 1;
+      return {
+        month: monthNames[monthIndex],
+        users: Number(item.users),
+        sessions: Number(item.sessions),
+      };
+    });
+
+    return {
+      cards: {
+        sessionsToday: {
+          value: sessionsTodayCount,
+          change: sessionsChange,
+        },
+        activeUsers: {
+          value: activeUsersCount,
+          change: usersChange,
+        },
+        emailsSent: {
+          value: emailsSentCount,
+          change: emailsChange,
+        },
+        roles: {
+          value: rolesCount,
+          change: rolesChange,
+        },
+      },
+      charts: {
+        emailsPerWeek: emailWeekData,
+        permissionDistribution: permissionsData,
+        sessionActivity: sessionActivityData,
+        userGrowth: userGrowthData,
+      },
+    };
   }
 
   async getUserLayout(userId: number, slug: string, localeCode: string) {
-    const dashboard = await this.prismaService.dashboard.findFirst({
-      where: { slug },
-    });
+    const dashboard = await this.prismaService.dashboard.findFirst({ where: { slug } });
 
     if (!dashboard) {
       return [];
@@ -318,10 +420,6 @@ export class DashboardCoreService {
       slug: component.slug,
       name: locale?.name || component.slug,
       description: locale?.description || '',
-      path: component.path,
-      icon: (component as any).icon || null,
-      stat_key: (component as any).stat_key || null,
-      color: (component as any).color || null,
       x: userLayout.x_axis,
       y: userLayout.y_axis,
       w: userLayout.width,

package/src/dashboard/dashboard.module.ts

@@ -1,6 +1,7 @@
 import { LocaleModule } from '@hed-hog/api-locale';
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { forwardRef, Module } from '@nestjs/common';
+import { DashboardComponentRoleModule } from './dashboard-component-role/dashboard-component-role.module';
 import { DashboardComponentModule } from './dashboard-component/dashboard-component.module';
 import { DashboardCoreModule } from './dashboard-core/dashboard-core.module';
 import { DashboardItemModule } from './dashboard-item/dashboard-item.module';
@@ -13,6 +14,7 @@ import { DashboardCrudModule } from './dashboard/dashboard.module';
     forwardRef(() => PrismaModule),
     forwardRef(() => DashboardCrudModule),
     forwardRef(() => DashboardComponentModule),
+    forwardRef(() => DashboardComponentRoleModule),
     forwardRef(() => DashboardItemModule),
     forwardRef(() => DashboardUserModule),
     forwardRef(() => DashboardCoreModule),