feat: add analyze apis

Author: Innei

apps/core/src/common/interceptors/analyze.interceptor.ts

@@ -116,6 +116,7 @@ export class AnalyzeInterceptor implements NestInterceptor {
           path: new URL(`http://a.com${url}`).pathname,
           country:
             request.headers['cf-ipcountry'] || request.headers['CF-IPCountry'],
+          referer: request.headers.referer || request.headers.Referer,
         })
 
         // ip access in redis

apps/core/src/modules/activity/activity.controller.ts

@@ -151,6 +151,19 @@ export class ActivityController {
     }
   }
 
+  @Get('/online-count')
+  async getOnlineCount() {
+    const roomInfo = await this.service.getAllRoomNames()
+    const total = Object.values(roomInfo.roomCount).reduce(
+      (acc: number, count: number) => acc + count,
+      0,
+    )
+    return {
+      total,
+      rooms: roomInfo.roomCount,
+    }
+  }
+
   @Auth()
   @Get('/reading/rank')
   async getReadingRangeRank(@Query() query: ActivityRangeDto) {

apps/core/src/modules/analyze/analyze.controller.ts

@@ -160,6 +160,18 @@ export class AnalyzeController {
     )
   }
 
+  @Get('/traffic-source')
+  async getTrafficSource(@Query() query: AnalyzeDto) {
+    const { from, to } = query
+    return this.service.getTrafficSource(from, to)
+  }
+
+  @Get('/device')
+  async getDeviceDistribution(@Query() query: AnalyzeDto) {
+    const { from, to } = query
+    return this.service.getDeviceDistribution(from, to)
+  }
+
   @Delete('/')
   @HttpCode(204)
   async clearAnalyze(@Query() query: AnalyzeDto) {

apps/core/src/modules/analyze/analyze.model.ts

@@ -30,5 +30,8 @@ export class AnalyzeModel extends BaseModel {
   @prop()
   path?: string
 
+  @prop()
+  referer?: string
+
   timestamp: Date
 }

apps/core/src/modules/analyze/analyze.service.ts

@@ -291,4 +291,185 @@ export class AnalyzeService {
 
     return fromRedisIps
   }
+
+  async getDeviceDistribution(from?: Date, to?: Date) {
+    from = from ?? new Date(Date.now() - 1000 * 24 * 3600 * 7)
+    to = to ?? new Date()
+
+    const result = await this.analyzeModel.aggregate([
+      {
+        $match: {
+          timestamp: {
+            $gte: from,
+            $lte: to,
+          },
+        },
+      },
+      {
+        $project: {
+          browser: { $ifNull: ['$ua.browser.name', 'Unknown'] },
+          os: { $ifNull: ['$ua.os.name', 'Unknown'] },
+          device: { $ifNull: ['$ua.device.type', 'desktop'] },
+        },
+      },
+      {
+        $facet: {
+          browsers: [
+            { $group: { _id: '$browser', count: { $sum: 1 } } },
+            { $sort: { count: -1 } },
+            { $limit: 10 },
+          ],
+          os: [
+            { $group: { _id: '$os', count: { $sum: 1 } } },
+            { $sort: { count: -1 } },
+            { $limit: 10 },
+          ],
+          devices: [
+            { $group: { _id: '$device', count: { $sum: 1 } } },
+            { $sort: { count: -1 } },
+          ],
+        },
+      },
+    ])
+
+    const data = result[0] || { browsers: [], os: [], devices: [] }
+
+    const deviceTypeMap: Record<string, string> = {
+      desktop: '桌面端',
+      mobile: '移动端',
+      tablet: '平板',
+      unknown: '未知',
+    }
+
+    return {
+      browsers: data.browsers.map((item: any) => ({
+        name: item._id || 'Unknown',
+        value: item.count,
+      })),
+      os: data.os.map((item: any) => ({
+        name: item._id || 'Unknown',
+        value: item.count,
+      })),
+      devices: data.devices.map((item: any) => ({
+        name: deviceTypeMap[item._id?.toLowerCase()] || item._id || '桌面端',
+        value: item.count,
+      })),
+    }
+  }
+
+  async getTrafficSource(from?: Date, to?: Date) {
+    from = from ?? new Date(Date.now() - 1000 * 24 * 3600 * 7)
+    to = to ?? new Date()
+
+    const result = await this.analyzeModel.aggregate([
+      {
+        $match: {
+          timestamp: {
+            $gte: from,
+            $lte: to,
+          },
+        },
+      },
+      {
+        $project: {
+          referer: { $ifNull: ['$referer', ''] },
+        },
+      },
+      {
+        $group: {
+          _id: '$referer',
+          count: { $sum: 1 },
+        },
+      },
+      {
+        $sort: { count: -1 },
+      },
+    ])
+
+    const categories: Record<string, number> = {
+      direct: 0,
+      search: 0,
+      social: 0,
+      other: 0,
+    }
+
+    const searchEngines = [
+      'google',
+      'bing',
+      'baidu',
+      'sogou',
+      'so.com',
+      '360.cn',
+      'yahoo',
+      'duckduckgo',
+      'yandex',
+    ]
+    const socialNetworks = [
+      'twitter',
+      'x.com',
+      'facebook',
+      'weibo',
+      'zhihu',
+      'douban',
+      'reddit',
+      'linkedin',
+      'instagram',
+      'tiktok',
+      'youtube',
+      'bilibili',
+      't.me',
+      'telegram',
+      'discord',
+    ]
+
+    const details: Array<{ source: string; count: number }> = []
+
+    for (const item of result) {
+      const referer = (item._id as string).toLowerCase()
+      const count = item.count as number
+
+      if (!referer || referer === '') {
+        categories.direct += count
+        continue
+      }
+
+      let hostname = ''
+      try {
+        hostname = new URL(referer).hostname.toLowerCase()
+      } catch {
+        categories.other += count
+        continue
+      }
+
+      const isSearch = searchEngines.some((engine) => hostname.includes(engine))
+      const isSocial = socialNetworks.some((network) =>
+        hostname.includes(network),
+      )
+
+      if (isSearch) {
+        categories.search += count
+      } else if (isSocial) {
+        categories.social += count
+      } else {
+        categories.other += count
+      }
+
+      const existing = details.find((d) => d.source === hostname)
+      if (existing) {
+        existing.count += count
+      } else {
+        details.push({ source: hostname, count })
+      }
+    }
+
+    return {
+      categories: [
+        { name: '直接访问', value: categories.direct },
+        { name: '搜索引擎', value: categories.search },
+        { name: '社交媒体', value: categories.social },
+        { name: '其他来源', value: categories.other },
+      ].filter((c) => c.value > 0),
+      details: details.sort((a, b) => b.count - a.count).slice(0, 10),
+    }
+  }
 }

scripts/seed-analyze-data.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+/**
+ * 向 Analyze 表插入 500 条测试数据
+ * 运行: node scripts/seed-analyze-data.mjs
+ */
+
+import { MongoClient } from 'mongodb'
+
+const MONGO_URI = process.env.MONGO_CONNECTION || 'mongodb://localhost:27017/mx-space'
+const COLLECTION_NAME = 'analyzes'
+
+// 模拟数据
+const browsers = [
+  { name: 'Chrome', version: '120.0.0' },
+  { name: 'Firefox', version: '121.0' },
+  { name: 'Safari', version: '17.0' },
+  { name: 'Edge', version: '120.0.0' },
+  { name: 'Opera', version: '105.0' },
+]
+
+const osList = [
+  { name: 'Windows', version: '10' },
+  { name: 'Windows', version: '11' },
+  { name: 'macOS', version: '14.0' },
+  { name: 'Linux', version: '' },
+  { name: 'iOS', version: '17.0' },
+  { name: 'Android', version: '14' },
+]
+
+const devices = [
+  { type: 'desktop', vendor: '', model: '' },
+  { type: 'desktop', vendor: '', model: '' },
+  { type: 'desktop', vendor: '', model: '' },
+  { type: 'mobile', vendor: 'Apple', model: 'iPhone' },
+  { type: 'mobile', vendor: 'Samsung', model: 'Galaxy' },
+  { type: 'tablet', vendor: 'Apple', model: 'iPad' },
+]
+
+const paths = [
+  '/posts/hello-world',
+  '/posts/typescript-tips',
+  '/posts/vue-best-practices',
+  '/notes/1',
+  '/notes/2',
+  '/notes/3',
+  '/pages/about',
+  '/pages/links',
+  '/',
+  '/feed',
+  '/sitemap.xml',
+]
+
+const referers = [
+  '', // 直接访问
+  '',
+  '',
+  'https://www.google.com/search?q=blog',
+  'https://www.google.com/search?q=vue',
+  'https://www.baidu.com/s?wd=blog',
+  'https://www.bing.com/search?q=typescript',
+  'https://twitter.com/someuser/status/123',
+  'https://x.com/someuser/status/456',
+  'https://weibo.com/detail/123456',
+  'https://www.zhihu.com/question/123456',
+  'https://github.com/user/repo',
+  'https://reddit.com/r/programming',
+  'https://t.me/channel/123',
+]
+
+const countries = ['CN', 'US', 'JP', 'KR', 'GB', 'DE', 'FR', 'SG', 'HK', 'TW', null]
+
+function randomItem(arr) {
+  return arr[Math.floor(Math.random() * arr.length)]
+}
+
+function randomIP() {
+  return `${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}.${Math.floor(Math.random() * 255)}`
+}
+
+function generateRecord(timestamp) {
+  const browser = randomItem(browsers)
+  const os = randomItem(osList)
+  const device = randomItem(devices)
+
+  return {
+    ip: randomIP(),
+    ua: {
+      browser: { name: browser.name, version: browser.version, major: browser.version.split('.')[0] },
+      os: { name: os.name, version: os.version },
+      device: { type: device.type, vendor: device.vendor, model: device.model },
+      engine: { name: 'Blink', version: '120.0.0' },
+      cpu: { architecture: 'amd64' },
+    },
+    path: randomItem(paths),
+    referer: randomItem(referers),
+    country: randomItem(countries),
+    timestamp: new Date(timestamp),
+  }
+}
+
+async function main() {
+  console.log('Connecting to MongoDB...')
+  const client = new MongoClient(MONGO_URI)
+
+  try {
+    await client.connect()
+    console.log('Connected!')
+
+    const db = client.db()
+    const collection = db.collection(COLLECTION_NAME)
+
+    // 生成过去 7 天的数据
+    const now = Date.now()
+    const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000
+
+    const records = []
+    for (let i = 0; i < 500; i++) {
+      const timestamp = sevenDaysAgo + Math.random() * (now - sevenDaysAgo)
+      records.push(generateRecord(timestamp))
+    }
+
+    console.log(`Inserting ${records.length} records...`)
+    const result = await collection.insertMany(records)
+    console.log(`Inserted ${result.insertedCount} records successfully!`)
+
+    // 显示统计信息
+    const stats = await collection.aggregate([
+      {
+        $facet: {
+          total: [{ $count: 'count' }],
+          byDevice: [
+            { $group: { _id: '$ua.device.type', count: { $sum: 1 } } },
+            { $sort: { count: -1 } },
+          ],
+          byBrowser: [
+            { $group: { _id: '$ua.browser.name', count: { $sum: 1 } } },
+            { $sort: { count: -1 } },
+          ],
+        },
+      },
+    ]).toArray()
+
+    console.log('\n--- Statistics ---')
+    console.log('Total records:', stats[0].total[0]?.count || 0)
+    console.log('By device:', stats[0].byDevice)
+    console.log('By browser:', stats[0].byBrowser)
+
+  } catch (err) {
+    console.error('Error:', err)
+    process.exit(1)
+  } finally {
+    await client.close()
+    console.log('\nDone!')
+  }
+}
+
+main()