@zumito-team/analytics-module 0.6.0 → 0.8.0

package/dist/events/discord/MessageCreate.js

@@ -13,6 +13,6 @@ export class MessageCreate extends FrameworkEvent {
             return;
         if (message.author?.bot)
             return;
-        await this.collector.recordMessage(message.guildId);
+        await this.collector.recordMessage(message.guildId, message.channelId, message.author?.id);
     }
 }

package/dist/index.d.ts

@@ -14,4 +14,5 @@ export { AnalyticsModuleConfig } from './config.js';
 export { GuildDailyStats } from './models/GuildDailyStats.js';
 export { CommandDailyStats } from './models/CommandDailyStats.js';
 export { VoiceChannelDailyStats } from './models/VoiceChannelDailyStats.js';
+export { ChannelMessageStats } from './models/ChannelMessageStats.js';
 export { GuildAnalyticsConfig } from './models/GuildAnalyticsConfig.js';

package/dist/index.js

@@ -24,7 +24,10 @@ export class AnalyticsModule extends Module {
                         {
                             label: 'Analiticas',
                             items: [
-                                { label: 'Dashboard', url: '/admin/analytics' },
+                                { label: 'Resumen', url: '/admin/analytics' },
+                                { label: 'Mensajes', url: '/admin/analytics/messages' },
+                                { label: 'Comandos', url: '/admin/analytics/commands' },
+                                { label: 'Crecimiento', url: '/admin/analytics/growth' },
                             ],
                         },
                     ],
@@ -37,9 +40,35 @@ export class AnalyticsModule extends Module {
         try {
             const { UserPanelNavigationService } = await import('@zumito-team/user-panel-module/services/UserPanelNavigationService');
             const nav = ServiceContainer.getService(UserPanelNavigationService);
-            nav.registerSubItems('dashboard', 'general', [
-                { id: 'analytics', label: 'analytics.sidebarTitle', url: '/panel/:guildId/analytics' },
-            ]);
+            nav.registerItem({
+                id: 'analytics',
+                icon: `<svg xmlns="http://www.w3.org/2000/svg" class="w-6 h-6 text-discord-white/60 group-hover:text-white" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M3 3v18h18"/><path d="M7 16l4-8 4 5 4-3"/></svg>`,
+                label: 'analytics.sidebarTitle',
+                url: '/panel/:guildId/analytics',
+                order: 3,
+                category: 'general',
+                sidebar: {
+                    showDropdown: false,
+                    sections: [
+                        {
+                            id: 'analytics-overview',
+                            label: 'analytics.overview',
+                            items: [
+                                { label: 'analytics.overview', url: '/panel/:guildId/analytics' },
+                            ],
+                        },
+                        {
+                            id: 'analytics-details',
+                            label: 'analytics.detailedStats',
+                            items: [
+                                { label: 'analytics.messages', url: '/panel/:guildId/analytics/messages' },
+                                { label: 'analytics.voice', url: '/panel/:guildId/analytics/voice' },
+                                { label: 'analytics.commands', url: '/panel/:guildId/analytics/commands' },
+                            ],
+                        },
+                    ],
+                },
+            });
         }
         catch (e) {
             console.warn('[AnalyticsModule] User panel not available, skipping user panel integration');
@@ -60,4 +89,5 @@ export { AnalyticsModuleConfig } from './config.js';
 export { GuildDailyStats } from './models/GuildDailyStats.js';
 export { CommandDailyStats } from './models/CommandDailyStats.js';
 export { VoiceChannelDailyStats } from './models/VoiceChannelDailyStats.js';
+export { ChannelMessageStats } from './models/ChannelMessageStats.js';
 export { GuildAnalyticsConfig } from './models/GuildAnalyticsConfig.js';

package/dist/models/ChannelMessageStats.d.ts

@@ -0,0 +1,8 @@
+export declare class ChannelMessageStats {
+    id: string;
+    guild_id: string;
+    channel_id: string;
+    date: string;
+    message_count: number;
+    unique_authors: number;
+}

package/dist/models/ChannelMessageStats.js

@@ -0,0 +1,31 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Collection, Field } from 'zumito-framework';
+let ChannelMessageStats = class ChannelMessageStats {
+};
+__decorate([
+    Field({ type: 'string', primary: true, unique: true })
+], ChannelMessageStats.prototype, "id", void 0);
+__decorate([
+    Field({ type: 'string' })
+], ChannelMessageStats.prototype, "guild_id", void 0);
+__decorate([
+    Field({ type: 'string' })
+], ChannelMessageStats.prototype, "channel_id", void 0);
+__decorate([
+    Field({ type: 'string' })
+], ChannelMessageStats.prototype, "date", void 0);
+__decorate([
+    Field({ type: 'number', default: 0 })
+], ChannelMessageStats.prototype, "message_count", void 0);
+__decorate([
+    Field({ type: 'number', default: 0 })
+], ChannelMessageStats.prototype, "unique_authors", void 0);
+ChannelMessageStats = __decorate([
+    Collection({ name: 'analytics_channel_message_stats' })
+], ChannelMessageStats);
+export { ChannelMessageStats };

package/dist/routes/AdminAnalytics.d.ts

@@ -1,11 +1,9 @@
 import { Route, RouteMethod } from 'zumito-framework';
-import { Client } from 'zumito-framework/discord';
 import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
 export declare class AdminAnalytics extends Route {
     private collector;
-    private client;
     method: RouteMethod;
     path: string;
-    constructor(collector?: AnalyticsCollector, client?: Client);
+    constructor(collector?: AnalyticsCollector);
     execute(req: any, res: any): Promise<void>;
 }

package/dist/routes/AdminAnalytics.js

@@ -2,14 +2,12 @@ import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
 import path, { dirname } from 'path';
 import { fileURLToPath } from 'url';
 import ejs from 'ejs';
-import { Client } from 'zumito-framework/discord';
 import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 export class AdminAnalytics extends Route {
-    constructor(collector = ServiceContainer.getService(AnalyticsCollector), client = ServiceContainer.getService(Client)) {
+    constructor(collector = ServiceContainer.getService(AnalyticsCollector)) {
         super();
         this.collector = collector;
-        this.client = client;
         this.method = RouteMethod.get;
         this.path = '/admin/analytics';
     }
@@ -22,26 +20,7 @@ export class AdminAnalytics extends Route {
         const summary = await this.collector.getGlobalStatsSummary(daysBack);
         const guildGrowth = await this.collector.getGuildGrowth(daysBack);
         const messagesPerDay = await this.collector.getMessagesPerDay(daysBack);
-        const commandsPerDay = await this.collector.getCommandsPerDay(null, daysBack);
-        const topCommands = await this.collector.getTopCommands(null, daysBack);
-        const slowestCommands = await this.collector.getSlowestCommands(null, daysBack);
-        const chartData = {
-            guildGrowth,
-            messagesPerDay,
-            commandsPerDay,
-            topCommands,
-            slowestCommands,
-        };
-        const { TranslationManager } = await import('zumito-framework');
-        const tm = ServiceContainer.getService(TranslationManager);
-        const t = (key, params) => tm.get(key, 'en', params);
-        const content = await ejs.renderFile(path.resolve(__dirname, '../views/admin-analytics.ejs'), {
-            summary,
-            chartData,
-            slowestCommands: slowestCommands.length > 0 ? slowestCommands : undefined,
-            t,
-            daysBack,
-        });
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/admin-analytics.ejs'), { summary, guildGrowth, messagesPerDay });
         const { AdminViewService } = await import('@zumito-team/admin-module/services/AdminViewService.js');
         const view = ServiceContainer.getService(AdminViewService);
         const html = await view.render({

package/dist/routes/AdminAnalyticsCommands.d.ts

@@ -0,0 +1,7 @@
+import { Route, RouteMethod } from 'zumito-framework';
+export declare class AdminAnalyticsCommands extends Route {
+    method: RouteMethod;
+    path: string;
+    private collector;
+    execute(req: any, res: any): Promise<void>;
+}

package/dist/routes/AdminAnalyticsCommands.js

@@ -0,0 +1,34 @@
+import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class AdminAnalyticsCommands extends Route {
+    constructor() {
+        super(...arguments);
+        this.method = RouteMethod.get;
+        this.path = '/admin/analytics/commands';
+        this.collector = ServiceContainer.getService(AnalyticsCollector);
+    }
+    async execute(req, res) {
+        const { AdminAuthService } = await import('@zumito-team/admin-module/services/AdminAuthService.js');
+        const auth = await ServiceContainer.getService(AdminAuthService).isLoginValid(req);
+        if (!auth?.isValid)
+            return res.redirect('/admin/login');
+        const daysBack = parseInt(req.query.days) || 7;
+        const commandsPerDay = await this.collector.getCommandsPerDay(null, daysBack);
+        const topCommands = await this.collector.getTopCommands(null, daysBack, 15);
+        const slowestCommands = await this.collector.getSlowestCommands(null, daysBack, 10);
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/admin-analytics-commands.ejs'), { commandsPerDay, topCommands, slowestCommands, daysBack });
+        const { AdminViewService } = await import('@zumito-team/admin-module/services/AdminViewService.js');
+        const view = ServiceContainer.getService(AdminViewService);
+        const html = await view.render({
+            title: 'Analiticas - Comandos',
+            content,
+            reqPath: this.path,
+            user: { name: 'Admin' },
+        });
+        res.send(html);
+    }
+}

package/dist/routes/AdminAnalyticsGrowth.d.ts

@@ -0,0 +1,7 @@
+import { Route, RouteMethod } from 'zumito-framework';
+export declare class AdminAnalyticsGrowth extends Route {
+    method: RouteMethod;
+    path: string;
+    private collector;
+    execute(req: any, res: any): Promise<void>;
+}

package/dist/routes/AdminAnalyticsGrowth.js

@@ -0,0 +1,34 @@
+import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class AdminAnalyticsGrowth extends Route {
+    constructor() {
+        super(...arguments);
+        this.method = RouteMethod.get;
+        this.path = '/admin/analytics/growth';
+        this.collector = ServiceContainer.getService(AnalyticsCollector);
+    }
+    async execute(req, res) {
+        const { AdminAuthService } = await import('@zumito-team/admin-module/services/AdminAuthService.js');
+        const auth = await ServiceContainer.getService(AdminAuthService).isLoginValid(req);
+        if (!auth?.isValid)
+            return res.redirect('/admin/login');
+        const daysBack = parseInt(req.query.days) || 30;
+        const guildGrowth = await this.collector.getGuildGrowth(daysBack);
+        const summary = await this.collector.getGlobalStatsSummary(daysBack);
+        const totalGuilds = Math.max(summary.totalGuilds, guildGrowth.length > 0 ? guildGrowth[guildGrowth.length - 1].guildCount : 0);
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/admin-analytics-growth.ejs'), { guildGrowth, totalGuilds, summary, daysBack });
+        const { AdminViewService } = await import('@zumito-team/admin-module/services/AdminViewService.js');
+        const view = ServiceContainer.getService(AdminViewService);
+        const html = await view.render({
+            title: 'Analiticas - Crecimiento',
+            content,
+            reqPath: this.path,
+            user: { name: 'Admin' },
+        });
+        res.send(html);
+    }
+}

package/dist/routes/AdminAnalyticsMessages.d.ts

@@ -0,0 +1,7 @@
+import { Route, RouteMethod } from 'zumito-framework';
+export declare class AdminAnalyticsMessages extends Route {
+    method: RouteMethod;
+    path: string;
+    private collector;
+    execute(req: any, res: any): Promise<void>;
+}

package/dist/routes/AdminAnalyticsMessages.js

@@ -0,0 +1,32 @@
+import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class AdminAnalyticsMessages extends Route {
+    constructor() {
+        super(...arguments);
+        this.method = RouteMethod.get;
+        this.path = '/admin/analytics/messages';
+        this.collector = ServiceContainer.getService(AnalyticsCollector);
+    }
+    async execute(req, res) {
+        const { AdminAuthService } = await import('@zumito-team/admin-module/services/AdminAuthService.js');
+        const auth = await ServiceContainer.getService(AdminAuthService).isLoginValid(req);
+        if (!auth?.isValid)
+            return res.redirect('/admin/login');
+        const daysBack = parseInt(req.query.days) || 7;
+        const messagesPerDay = await this.collector.getMessagesPerDay(daysBack);
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/admin-analytics-messages.ejs'), { messagesPerDay, daysBack });
+        const { AdminViewService } = await import('@zumito-team/admin-module/services/AdminViewService.js');
+        const view = ServiceContainer.getService(AdminViewService);
+        const html = await view.render({
+            title: 'Analiticas - Mensajes',
+            content,
+            reqPath: this.path,
+            user: { name: 'Admin' },
+        });
+        res.send(html);
+    }
+}

package/dist/routes/UserPanelAnalytics.js

@@ -57,23 +57,7 @@ export class UserPanelAnalytics extends Route {
             leavesPerDay.push({ date: s.date, count: s.leave_count });
             voicePerDay.push({ date: s.date, count: s.voice_minutes });
         }
-        const commandsPerDay = await this.collector.getCommandsPerDay(guildId, daysBack);
-        const topCommands = await this.collector.getTopCommands(guildId, daysBack);
-        const slowestCommands = await this.collector.getSlowestCommands(guildId, daysBack);
-        const channelVoice = await this.collector.getVoiceChannelStats(guildId, daysBack);
-        const chartData = {
-            messagesPerDay, joinsPerDay, leavesPerDay, voicePerDay,
-            commandsPerDay, topCommands, slowestCommands, channelVoice,
-        };
-        const config = await this.collector.getConfig(guildId);
-        const content = await ejs.renderFile(path.resolve(__dirname, '../views/user-analytics.ejs'), {
-            guildSummary,
-            chartData,
-            slowestCommands: (config.track_command_performance && slowestCommands.length > 0) ? slowestCommands : undefined,
-            channelVoice: (config.track_per_channel_voice && channelVoice.length > 0) ? channelVoice : undefined,
-            t,
-            daysBack,
-        });
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/user-analytics.ejs'), { guildSummary, messagesPerDay, joinsPerDay, leavesPerDay, t });
         const view = ServiceContainer.getService(UserPanelViewService);
         const html = await view.render({ content, reqPath: req.path, req, res });
         res.send(html);

package/dist/routes/UserPanelAnalyticsCommands.d.ts

@@ -0,0 +1,8 @@
+import { Route, RouteMethod } from 'zumito-framework';
+export declare class UserPanelAnalyticsCommands extends Route {
+    method: RouteMethod;
+    path: string;
+    private collector;
+    private client;
+    execute(req: any, res: any): Promise<void>;
+}

package/dist/routes/UserPanelAnalyticsCommands.js

@@ -0,0 +1,48 @@
+import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { Client, PermissionFlagsBits } from 'zumito-framework/discord';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class UserPanelAnalyticsCommands extends Route {
+    constructor() {
+        super(...arguments);
+        this.method = RouteMethod.get;
+        this.path = '/panel/:guildId/analytics/commands';
+        this.collector = ServiceContainer.getService(AnalyticsCollector);
+        this.client = ServiceContainer.getService(Client);
+    }
+    async execute(req, res) {
+        const { UserPanelAuthService } = await import('@zumito-team/user-panel-module/services/UserPanelAuthService');
+        const { UserPanelViewService } = await import('@zumito-team/user-panel-module/services/UserPanelViewService');
+        const { UserPanelLanguageManager } = await import('@zumito-team/user-panel-module/services/UserPanelLanguageManager');
+        const authService = ServiceContainer.getService(UserPanelAuthService);
+        const authData = await authService.isLoginValid(req);
+        if (!authData.isValid)
+            return res.redirect('/panel/login');
+        const userId = authData.data.discordUserData.id;
+        const guildId = req.params.guildId;
+        const guild = this.client.guilds.cache.get(guildId);
+        if (!guild)
+            return res.status(404).send('Server not found');
+        let member = guild.members.cache.get(userId);
+        if (!member)
+            member = await guild.members.fetch(userId).catch(() => null);
+        if (!member || !(member.permissions.has(PermissionFlagsBits.Administrator) ||
+            member.permissions.has(PermissionFlagsBits.ManageGuild) || guild.ownerId === userId)) {
+            return res.status(403).send('No tienes permisos en este servidor');
+        }
+        const daysBack = parseInt(req.query.days) || 7;
+        const langMgr = ServiceContainer.getService(UserPanelLanguageManager);
+        const { t } = langMgr.getLanguageVariables(req, res);
+        const commandsPerDay = await this.collector.getCommandsPerDay(guildId, daysBack);
+        const topCommands = await this.collector.getTopCommands(guildId, daysBack, 15);
+        const slowestCommands = await this.collector.getSlowestCommands(guildId, daysBack, 10);
+        const config = await this.collector.getConfig(guildId);
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/user-analytics-commands.ejs'), { commandsPerDay, topCommands, slowestCommands: config.track_command_performance ? slowestCommands : null, t, daysBack });
+        const view = ServiceContainer.getService(UserPanelViewService);
+        const html = await view.render({ content, reqPath: req.path, req, res });
+        res.send(html);
+    }
+}

package/dist/routes/UserPanelAnalyticsMessages.d.ts

@@ -0,0 +1,8 @@
+import { Route, RouteMethod } from 'zumito-framework';
+export declare class UserPanelAnalyticsMessages extends Route {
+    method: RouteMethod;
+    path: string;
+    private collector;
+    private client;
+    execute(req: any, res: any): Promise<void>;
+}

package/dist/routes/UserPanelAnalyticsMessages.js

@@ -0,0 +1,52 @@
+import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { Client, PermissionFlagsBits } from 'zumito-framework/discord';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class UserPanelAnalyticsMessages extends Route {
+    constructor() {
+        super(...arguments);
+        this.method = RouteMethod.get;
+        this.path = '/panel/:guildId/analytics/messages';
+        this.collector = ServiceContainer.getService(AnalyticsCollector);
+        this.client = ServiceContainer.getService(Client);
+    }
+    async execute(req, res) {
+        const { UserPanelAuthService } = await import('@zumito-team/user-panel-module/services/UserPanelAuthService');
+        const { UserPanelViewService } = await import('@zumito-team/user-panel-module/services/UserPanelViewService');
+        const { UserPanelLanguageManager } = await import('@zumito-team/user-panel-module/services/UserPanelLanguageManager');
+        const authService = ServiceContainer.getService(UserPanelAuthService);
+        const authData = await authService.isLoginValid(req);
+        if (!authData.isValid)
+            return res.redirect('/panel/login');
+        const userId = authData.data.discordUserData.id;
+        const guildId = req.params.guildId;
+        const guild = this.client.guilds.cache.get(guildId);
+        if (!guild)
+            return res.status(404).send('Server not found');
+        let member = guild.members.cache.get(userId);
+        if (!member)
+            member = await guild.members.fetch(userId).catch(() => null);
+        if (!member || !(member.permissions.has(PermissionFlagsBits.Administrator) ||
+            member.permissions.has(PermissionFlagsBits.ManageGuild) || guild.ownerId === userId)) {
+            return res.status(403).send('No tienes permisos en este servidor');
+        }
+        const daysBack = parseInt(req.query.days) || 7;
+        const langMgr = ServiceContainer.getService(UserPanelLanguageManager);
+        const { t } = langMgr.getLanguageVariables(req, res);
+        const stats = await this.collector.getGuildStats(guildId, daysBack);
+        let totalMessages = 0;
+        const messagesPerDay = [];
+        for (const s of stats) {
+            totalMessages += s.message_count;
+            messagesPerDay.push({ date: s.date, count: s.message_count });
+        }
+        const channelMessages = await this.collector.getChannelMessageStats(guildId, daysBack);
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/user-analytics-messages.ejs'), { totalMessages, messagesPerDay, channelMessages, t, daysBack });
+        const view = ServiceContainer.getService(UserPanelViewService);
+        const html = await view.render({ content, reqPath: req.path, req, res });
+        res.send(html);
+    }
+}

package/dist/routes/UserPanelAnalyticsVoice.d.ts

@@ -0,0 +1,8 @@
+import { Route, RouteMethod } from 'zumito-framework';
+export declare class UserPanelAnalyticsVoice extends Route {
+    method: RouteMethod;
+    path: string;
+    private collector;
+    private client;
+    execute(req: any, res: any): Promise<void>;
+}

package/dist/routes/UserPanelAnalyticsVoice.js

@@ -0,0 +1,53 @@
+import { Route, RouteMethod, ServiceContainer } from 'zumito-framework';
+import path, { dirname } from 'path';
+import { fileURLToPath } from 'url';
+import ejs from 'ejs';
+import { Client, PermissionFlagsBits } from 'zumito-framework/discord';
+import { AnalyticsCollector } from '../services/AnalyticsCollector.js';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export class UserPanelAnalyticsVoice extends Route {
+    constructor() {
+        super(...arguments);
+        this.method = RouteMethod.get;
+        this.path = '/panel/:guildId/analytics/voice';
+        this.collector = ServiceContainer.getService(AnalyticsCollector);
+        this.client = ServiceContainer.getService(Client);
+    }
+    async execute(req, res) {
+        const { UserPanelAuthService } = await import('@zumito-team/user-panel-module/services/UserPanelAuthService');
+        const { UserPanelViewService } = await import('@zumito-team/user-panel-module/services/UserPanelViewService');
+        const { UserPanelLanguageManager } = await import('@zumito-team/user-panel-module/services/UserPanelLanguageManager');
+        const authService = ServiceContainer.getService(UserPanelAuthService);
+        const authData = await authService.isLoginValid(req);
+        if (!authData.isValid)
+            return res.redirect('/panel/login');
+        const userId = authData.data.discordUserData.id;
+        const guildId = req.params.guildId;
+        const guild = this.client.guilds.cache.get(guildId);
+        if (!guild)
+            return res.status(404).send('Server not found');
+        let member = guild.members.cache.get(userId);
+        if (!member)
+            member = await guild.members.fetch(userId).catch(() => null);
+        if (!member || !(member.permissions.has(PermissionFlagsBits.Administrator) ||
+            member.permissions.has(PermissionFlagsBits.ManageGuild) || guild.ownerId === userId)) {
+            return res.status(403).send('No tienes permisos en este servidor');
+        }
+        const daysBack = parseInt(req.query.days) || 7;
+        const langMgr = ServiceContainer.getService(UserPanelLanguageManager);
+        const { t } = langMgr.getLanguageVariables(req, res);
+        const stats = await this.collector.getGuildStats(guildId, daysBack);
+        const channelVoice = await this.collector.getVoiceChannelStats(guildId, daysBack);
+        let totalVoice = 0;
+        const voicePerDay = [];
+        for (const s of stats) {
+            totalVoice += s.voice_minutes;
+            voicePerDay.push({ date: s.date, count: s.voice_minutes });
+        }
+        const config = await this.collector.getConfig(guildId);
+        const content = await ejs.renderFile(path.resolve(__dirname, '../views/user-analytics-voice.ejs'), { totalVoice, voicePerDay, channelVoice: config.track_per_channel_voice ? channelVoice : null, t, daysBack });
+        const view = ServiceContainer.getService(UserPanelViewService);
+        const html = await view.render({ content, reqPath: req.path, req, res });
+        res.send(html);
+    }
+}

package/dist/services/AnalyticsCollector.d.ts

@@ -2,6 +2,7 @@ import { GuildDailyStats } from '../models/GuildDailyStats.js';
 import { CommandDailyStats } from '../models/CommandDailyStats.js';
 import { VoiceChannelDailyStats } from '../models/VoiceChannelDailyStats.js';
 import { GuildAnalyticsConfig } from '../models/GuildAnalyticsConfig.js';
+import { ChannelMessageStats } from '../models/ChannelMessageStats.js';
 export interface CommandExecutedPayload {
     guildId: string;
     commandName: string;
@@ -13,11 +14,13 @@ export declare class AnalyticsCollector {
     private db;
     private voiceSessions;
     private dailyVoiceUsers;
+    private dailyMessageAuthors;
+    private dailyChannelMessageAuthors;
     private cleanupTimer;
     constructor(db?: any);
     private repo;
     private ensuredConfig;
-    recordMessage(guildId: string): Promise<void>;
+    recordMessage(guildId: string, channelId?: string, authorId?: string): Promise<void>;
     recordMemberJoin(guildId: string): Promise<void>;
     recordMemberLeave(guildId: string): Promise<void>;
     recordVoiceJoin(guildId: string, channelId: string, userId: string): Promise<void>;
@@ -52,6 +55,7 @@ export declare class AnalyticsCollector {
         avgExecutionTimeMs: number;
     })[]>;
     getVoiceChannelStats(guildId: string, daysBack: number): Promise<VoiceChannelDailyStats[]>;
+    getChannelMessageStats(guildId: string, daysBack: number): Promise<ChannelMessageStats[]>;
     getConfig(guildId: string): Promise<GuildAnalyticsConfig>;
     updateConfig(guildId: string, partial: Partial<GuildAnalyticsConfig>): Promise<void>;
     runCleanup(): Promise<void>;

package/dist/services/AnalyticsCollector.js

@@ -3,6 +3,7 @@ import { GuildDailyStats } from '../models/GuildDailyStats.js';
 import { CommandDailyStats } from '../models/CommandDailyStats.js';
 import { VoiceChannelDailyStats } from '../models/VoiceChannelDailyStats.js';
 import { GuildAnalyticsConfig } from '../models/GuildAnalyticsConfig.js';
+import { ChannelMessageStats } from '../models/ChannelMessageStats.js';
 import { AnalyticsModuleConfig } from '../config.js';
 function today() {
     return new Date().toISOString().slice(0, 10);
@@ -12,6 +13,8 @@ export class AnalyticsCollector {
         this.db = db;
         this.voiceSessions = new Map();
         this.dailyVoiceUsers = new Map();
+        this.dailyMessageAuthors = new Map();
+        this.dailyChannelMessageAuthors = new Map();
         this.cleanupTimer = null;
     }
     repo(name) {
@@ -38,11 +41,48 @@ export class AnalyticsCollector {
         await repo.insert(defaults);
         return defaults;
     }
-    async recordMessage(guildId) {
+    async recordMessage(guildId, channelId, authorId) {
         const config = await this.ensuredConfig(guildId);
         if (!config.enabled || !config.track_messages)
             return;
         await this.upsertGuildStats(guildId, { message_count: 1 });
+        // Track unique authors per day
+        if (authorId) {
+            const authorKey = `${guildId}_${today()}`;
+            if (!this.dailyMessageAuthors.has(authorKey)) {
+                this.dailyMessageAuthors.set(authorKey, new Set());
+            }
+            this.dailyMessageAuthors.get(authorKey).add(authorId);
+        }
+        // Track per-channel stats
+        if (channelId && config.track_per_channel_voice) {
+            const date = today();
+            const chanKey = `${guildId}_${channelId}_${date}`;
+            const repo = this.repo(ChannelMessageStats);
+            const existing = await repo.findOne({ id: chanKey });
+            if (authorId) {
+                if (!this.dailyChannelMessageAuthors.has(chanKey)) {
+                    this.dailyChannelMessageAuthors.set(chanKey, new Set());
+                }
+                this.dailyChannelMessageAuthors.get(chanKey).add(authorId);
+            }
+            if (existing) {
+                await repo.update({ id: chanKey }, {
+                    message_count: existing.message_count + 1,
+                    unique_authors: this.dailyChannelMessageAuthors.get(chanKey)?.size || 0,
+                });
+            }
+            else {
+                await repo.insert({
+                    id: chanKey,
+                    guild_id: guildId,
+                    channel_id: channelId,
+                    date,
+                    message_count: 1,
+                    unique_authors: 0,
+                });
+            }
+        }
     }
     async recordMemberJoin(guildId) {
         const config = await this.ensuredConfig(guildId);
@@ -374,8 +414,17 @@ export class AnalyticsCollector {
             error_count: data.errors,
             avgExecutionTimeMs: data.usage_count > 0 ? Math.round(data.totalTime / data.usage_count) : 0,
         }))
-            .filter(c => c.total_execution_time_ms > 0)
-            .sort((a, b) => b.avgExecutionTimeMs - a.avgExecutionTimeMs)
+            .sort((a, b) => {
+            const aHasPerf = a.total_execution_time_ms > 0;
+            const bHasPerf = b.total_execution_time_ms > 0;
+            if (aHasPerf && bHasPerf)
+                return b.avgExecutionTimeMs - a.avgExecutionTimeMs;
+            if (aHasPerf)
+                return -1;
+            if (bHasPerf)
+                return 1;
+            return b.usage_count - a.usage_count;
+        })
             .slice(0, limit);
     }
     async getVoiceChannelStats(guildId, daysBack) {
@@ -387,6 +436,15 @@ export class AnalyticsCollector {
             .sort('date', 'asc')
             .exec();
     }
+    async getChannelMessageStats(guildId, daysBack) {
+        const repo = this.repo(ChannelMessageStats);
+        const dateMin = this.dateDaysAgo(daysBack);
+        return repo.query()
+            .where('guild_id', 'eq', guildId)
+            .where('date', 'gte', dateMin)
+            .sort('date', 'asc')
+            .exec();
+    }
     // ── Config ───────────────────────────────────────────────────
     async getConfig(guildId) {
         return this.ensuredConfig(guildId);