Spaces:
Running
Running
| ; | |
| 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; | |
| }; | |
| var __metadata = (this && this.__metadata) || function (k, v) { | |
| if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v); | |
| }; | |
| var AnalyticsService_1; | |
| Object.defineProperty(exports, "__esModule", { value: true }); | |
| exports.AnalyticsService = void 0; | |
| const common_1 = require("@nestjs/common"); | |
| const prisma_service_1 = require("../prisma/prisma.service"); | |
| const authorization_service_1 = require("../common/authorization.service"); | |
| let AnalyticsService = AnalyticsService_1 = class AnalyticsService { | |
| prisma; | |
| authorizationService; | |
| logger = new common_1.Logger(AnalyticsService_1.name); | |
| cache = new Map(); | |
| cacheTTL = 30_000; | |
| constructor(prisma, authorizationService) { | |
| this.prisma = prisma; | |
| this.authorizationService = authorizationService; | |
| } | |
| getCached(key) { | |
| const entry = this.cache.get(key); | |
| if (entry && entry.expiresAt > Date.now()) | |
| return entry.data; | |
| this.cache.delete(key); | |
| return null; | |
| } | |
| setCache(key, data) { | |
| this.cache.set(key, { data, expiresAt: Date.now() + this.cacheTTL }); | |
| if (this.cache.size > 100) { | |
| const oldest = this.cache.keys().next().value; | |
| if (oldest) | |
| this.cache.delete(oldest); | |
| } | |
| } | |
| async getDashboardMetrics(podcastId, userId) { | |
| await this.authorizationService.checkPodcastAccess(podcastId, userId); | |
| const cached = this.getCached(`dashboard:${podcastId}`); | |
| if (cached) | |
| return cached; | |
| const [totalGuests, guestsByStatus, totalEpisodes, episodesByStatus, upcomingBookings, recentGuests, topPriorityGuests,] = await Promise.all([ | |
| this.prisma.guest.count({ where: { podcastId } }), | |
| this.prisma.guest.groupBy({ | |
| by: ["status"], | |
| where: { podcastId }, | |
| _count: { id: true }, | |
| }), | |
| this.prisma.episode.count({ where: { podcastId } }), | |
| this.prisma.episode.groupBy({ | |
| by: ["status"], | |
| where: { podcastId }, | |
| _count: { id: true }, | |
| }), | |
| this.prisma.booking.count({ | |
| where: { | |
| episode: { podcastId }, | |
| startTime: { gte: new Date() }, | |
| }, | |
| }), | |
| this.prisma.guest.findMany({ | |
| where: { podcastId }, | |
| orderBy: { createdAt: "desc" }, | |
| take: 5, | |
| select: { | |
| id: true, | |
| fullName: true, | |
| email: true, | |
| company: true, | |
| status: true, | |
| priorityScore: true, | |
| createdAt: true, | |
| }, | |
| }), | |
| this.prisma.guest.findMany({ | |
| where: { podcastId, status: { in: ["prospect", "contacted"] } }, | |
| orderBy: { priorityScore: "desc" }, | |
| take: 5, | |
| select: { | |
| id: true, | |
| fullName: true, | |
| company: true, | |
| title: true, | |
| priorityScore: true, | |
| }, | |
| }), | |
| ]); | |
| const guestStatusMap = {}; | |
| for (const item of guestsByStatus) { | |
| guestStatusMap[item.status] = item._count.id; | |
| } | |
| const episodeStatusMap = {}; | |
| for (const item of episodesByStatus) { | |
| episodeStatusMap[item.status] = item._count.id; | |
| } | |
| const result = { | |
| totalGuests, | |
| guestsByStatus: guestStatusMap, | |
| totalEpisodes, | |
| episodesByStatus: episodeStatusMap, | |
| upcomingBookings, | |
| recentGuests, | |
| topPriorityGuests, | |
| }; | |
| this.setCache(`dashboard:${podcastId}`, result); | |
| return result; | |
| } | |
| async getGuestPipeline(podcastId, userId) { | |
| await this.authorizationService.checkPodcastAccess(podcastId, userId); | |
| const cached = this.getCached(`pipeline:${podcastId}`); | |
| if (cached) | |
| return cached; | |
| const pipeline = await this.prisma.guest.groupBy({ | |
| by: ["status"], | |
| where: { podcastId }, | |
| _count: { id: true }, | |
| _avg: { priorityScore: true }, | |
| }); | |
| const result = pipeline.map((stage) => ({ | |
| status: stage.status, | |
| count: stage._count.id, | |
| avgScore: Math.round(stage._avg.priorityScore || 0), | |
| })); | |
| this.setCache(`pipeline:${podcastId}`, result); | |
| return result; | |
| } | |
| async getOutreachMetrics(podcastId, userId) { | |
| await this.authorizationService.checkPodcastAccess(podcastId, userId); | |
| const cached = this.getCached(`outreach:${podcastId}`); | |
| if (cached) | |
| return cached; | |
| const guests = await this.prisma.guest.findMany({ | |
| where: { podcastId }, | |
| select: { id: true }, | |
| }); | |
| const guestIds = guests.map((g) => g.id); | |
| if (guestIds.length === 0) { | |
| return { | |
| totalSequences: 0, | |
| activeSequences: 0, | |
| totalMessagesSent: 0, | |
| openRate: 0, | |
| clickRate: 0, | |
| replyRate: 0, | |
| }; | |
| } | |
| const [totalSequences, activeSequences, messageStats] = await Promise.all([ | |
| this.prisma.outreachSequence.count({ | |
| where: { guestId: { in: guestIds } }, | |
| }), | |
| this.prisma.outreachSequence.count({ | |
| where: { guestId: { in: guestIds }, status: "active" }, | |
| }), | |
| this.prisma.outreachMessage.aggregate({ | |
| where: { sequence: { guestId: { in: guestIds } } }, | |
| _count: { id: true, sentAt: true, openedAt: true, clickedAt: true }, | |
| }), | |
| ]); | |
| const sent = messageStats._count.sentAt; | |
| const opened = messageStats._count.openedAt; | |
| const clicked = messageStats._count.clickedAt; | |
| const result = { | |
| totalSequences, | |
| activeSequences, | |
| totalMessagesSent: sent, | |
| openRate: sent > 0 ? Math.round((opened / sent) * 100) : 0, | |
| clickRate: sent > 0 ? Math.round((clicked / sent) * 100) : 0, | |
| }; | |
| this.setCache(`outreach:${podcastId}`, result); | |
| return result; | |
| } | |
| async getSchedulingMetrics(podcastId, userId, daysBack = 90) { | |
| await this.authorizationService.checkPodcastAccess(podcastId, userId); | |
| const cacheKey = `scheduling:${podcastId}:${daysBack}`; | |
| const cached = this.getCached(cacheKey); | |
| if (cached) | |
| return cached; | |
| const since = new Date(Date.now() - daysBack * 24 * 60 * 60 * 1000); | |
| const [scheduledCount, recordedCount, publishedCount, avgDuration] = await Promise.all([ | |
| this.prisma.episode.count({ | |
| where: { | |
| podcastId, | |
| status: "scheduled", | |
| createdAt: { gte: since }, | |
| }, | |
| }), | |
| this.prisma.episode.count({ | |
| where: { | |
| podcastId, | |
| status: "recorded", | |
| createdAt: { gte: since }, | |
| }, | |
| }), | |
| this.prisma.episode.count({ | |
| where: { | |
| podcastId, | |
| status: "published", | |
| createdAt: { gte: since }, | |
| }, | |
| }), | |
| this.prisma.episode.aggregate({ | |
| where: { podcastId, durationMinutes: { not: null } }, | |
| _avg: { durationMinutes: true }, | |
| }), | |
| ]); | |
| const result = { | |
| scheduledCount, | |
| recordedCount, | |
| publishedCount, | |
| conversionRate: scheduledCount > 0 | |
| ? Math.round((recordedCount / scheduledCount) * 100) | |
| : 0, | |
| avgDurationMinutes: Math.round(avgDuration._avg.durationMinutes || 0), | |
| }; | |
| this.setCache(cacheKey, result); | |
| return result; | |
| } | |
| async getRecentActivity(podcastId, userId, limit = 20) { | |
| await this.authorizationService.checkPodcastAccess(podcastId, userId); | |
| const cacheKey = `recent:${podcastId}:${limit}`; | |
| const cached = this.getCached(cacheKey); | |
| if (cached) | |
| return cached; | |
| const [recentGuests, recentEpisodes, recentBookings, recentOutreach] = await Promise.all([ | |
| this.prisma.guest.findMany({ | |
| where: { podcastId }, | |
| orderBy: { createdAt: "desc" }, | |
| take: limit, | |
| select: { | |
| id: true, | |
| fullName: true, | |
| status: true, | |
| createdAt: true, | |
| _count: { | |
| select: { | |
| outreachSequences: true, | |
| }, | |
| }, | |
| }, | |
| }), | |
| this.prisma.episode.findMany({ | |
| where: { podcastId }, | |
| orderBy: { createdAt: "desc" }, | |
| take: limit, | |
| select: { | |
| id: true, | |
| title: true, | |
| status: true, | |
| scheduledAt: true, | |
| createdAt: true, | |
| guest: { | |
| select: { | |
| fullName: true, | |
| }, | |
| }, | |
| }, | |
| }), | |
| this.prisma.booking.findMany({ | |
| where: { episode: { podcastId } }, | |
| orderBy: { createdAt: "desc" }, | |
| take: limit, | |
| select: { | |
| id: true, | |
| startTime: true, | |
| isConfirmed: true, | |
| createdAt: true, | |
| episode: { | |
| select: { | |
| title: true, | |
| guest: { | |
| select: { | |
| fullName: true, | |
| }, | |
| }, | |
| }, | |
| }, | |
| }, | |
| }), | |
| this.prisma.outreachMessage.findMany({ | |
| where: { sequence: { guest: { podcastId } } }, | |
| orderBy: { sentAt: "desc" }, | |
| take: limit, | |
| select: { | |
| id: true, | |
| type: true, | |
| sentAt: true, | |
| openedAt: true, | |
| sequence: { | |
| select: { | |
| guest: { | |
| select: { | |
| fullName: true, | |
| }, | |
| }, | |
| }, | |
| }, | |
| }, | |
| }), | |
| ]); | |
| const activities = [ | |
| ...recentGuests.map((g) => ({ | |
| type: "guest_added", | |
| id: g.id, | |
| title: `New guest: ${g.fullName}`, | |
| status: g.status, | |
| timestamp: g.createdAt, | |
| })), | |
| ...recentEpisodes.map((e) => ({ | |
| type: "episode_created", | |
| id: e.id, | |
| title: `Episode: ${e.title}`, | |
| subtitle: `With ${e.guest.fullName}`, | |
| status: e.status, | |
| timestamp: e.createdAt, | |
| scheduledAt: e.scheduledAt, | |
| })), | |
| ...recentBookings.map((b) => ({ | |
| type: "booking_created", | |
| id: b.id, | |
| title: `Booking: ${b.episode.title}`, | |
| subtitle: `With ${b.episode.guest.fullName}`, | |
| timestamp: b.createdAt, | |
| startTime: b.startTime, | |
| isConfirmed: b.isConfirmed, | |
| })), | |
| ...recentOutreach.map((o) => ({ | |
| type: "message_sent", | |
| id: o.id, | |
| title: `Email sent to ${o.sequence.guest.fullName}`, | |
| subtitle: o.type, | |
| timestamp: o.sentAt, | |
| openedAt: o.openedAt, | |
| })), | |
| ]; | |
| const result = activities | |
| .filter((a) => a.timestamp != null) | |
| .sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime()) | |
| .slice(0, limit); | |
| this.setCache(cacheKey, result); | |
| return result; | |
| } | |
| }; | |
| exports.AnalyticsService = AnalyticsService; | |
| exports.AnalyticsService = AnalyticsService = AnalyticsService_1 = __decorate([ | |
| (0, common_1.Injectable)(), | |
| __metadata("design:paramtypes", [prisma_service_1.PrismaService, | |
| authorization_service_1.AuthorizationService]) | |
| ], AnalyticsService); | |
| //# sourceMappingURL=analytics.service.js.map |