Move dashboard server into project

inventory-server/dashboard/google-server/routes/analytics.js

@@ -0,0 +1,254 @@
+const express = require('express');
+const { BetaAnalyticsDataClient } = require('@google-analytics/data');
+const router = express.Router();
+const logger = require('../utils/logger');
+
+// Initialize GA4 client
+const analyticsClient = new BetaAnalyticsDataClient({
+  credentials: JSON.parse(process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON)
+});
+
+const propertyId = process.env.GA_PROPERTY_ID;
+
+// Cache durations
+const CACHE_DURATIONS = {
+  REALTIME_BASIC: 60, // 1 minute
+  REALTIME_DETAILED: 300, // 5 minutes
+  BASIC_METRICS: 3600, // 1 hour
+  USER_BEHAVIOR: 3600 // 1 hour
+};
+
+// Basic metrics endpoint
+router.get('/metrics', async (req, res) => {
+  try {
+    const { startDate = '7daysAgo' } = req.query;
+    const cacheKey = `analytics:basic_metrics:${startDate}`;
+
+    // Check Redis cache
+    const cachedData = await req.redisClient.get(cacheKey);
+    if (cachedData) {
+      logger.info('Returning cached basic metrics data');
+      return res.json({ success: true, data: JSON.parse(cachedData) });
+    }
+
+    // Fetch from GA4
+    const [response] = await analyticsClient.runReport({
+      property: `properties/${propertyId}`,
+      dateRanges: [{ startDate, endDate: 'today' }],
+      dimensions: [{ name: 'date' }],
+      metrics: [
+        { name: 'activeUsers' },
+        { name: 'newUsers' },
+        { name: 'averageSessionDuration' },
+        { name: 'screenPageViews' },
+        { name: 'bounceRate' },
+        { name: 'conversions' }
+      ],
+      returnPropertyQuota: true
+    });
+
+    // Cache the response
+    await req.redisClient.set(cacheKey, JSON.stringify(response), {
+      EX: CACHE_DURATIONS.BASIC_METRICS
+    });
+
+    res.json({ success: true, data: response });
+  } catch (error) {
+    logger.error('Error fetching basic metrics:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Realtime basic data endpoint
+router.get('/realtime/basic', async (req, res) => {
+  try {
+    const cacheKey = 'analytics:realtime:basic';
+    
+    // Check Redis cache
+    const cachedData = await req.redisClient.get(cacheKey);
+    if (cachedData) {
+      logger.info('Returning cached realtime basic data');
+      return res.json({ success: true, data: JSON.parse(cachedData) });
+    }
+
+    // Fetch active users
+    const [userResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      metrics: [{ name: 'activeUsers' }],
+      returnPropertyQuota: true
+    });
+
+    // Fetch last 5 minutes
+    const [fiveMinResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      metrics: [{ name: 'activeUsers' }],
+      minuteRanges: [{ startMinutesAgo: 5, endMinutesAgo: 0 }]
+    });
+
+    // Fetch time series data
+    const [timeSeriesResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      dimensions: [{ name: 'minutesAgo' }],
+      metrics: [{ name: 'activeUsers' }]
+    });
+
+    const response = {
+      userResponse,
+      fiveMinResponse,
+      timeSeriesResponse,
+      quotaInfo: {
+        projectHourly: userResponse.propertyQuota.tokensPerProjectPerHour,
+        daily: userResponse.propertyQuota.tokensPerDay,
+        serverErrors: userResponse.propertyQuota.serverErrorsPerProjectPerHour,
+        thresholdedRequests: userResponse.propertyQuota.potentiallyThresholdedRequestsPerHour
+      }
+    };
+
+    // Cache the response
+    await req.redisClient.set(cacheKey, JSON.stringify(response), {
+      EX: CACHE_DURATIONS.REALTIME_BASIC
+    });
+
+    res.json({ success: true, data: response });
+  } catch (error) {
+    logger.error('Error fetching realtime basic data:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Realtime detailed data endpoint
+router.get('/realtime/detailed', async (req, res) => {
+  try {
+    const cacheKey = 'analytics:realtime:detailed';
+    
+    // Check Redis cache
+    const cachedData = await req.redisClient.get(cacheKey);
+    if (cachedData) {
+      logger.info('Returning cached realtime detailed data');
+      return res.json({ success: true, data: JSON.parse(cachedData) });
+    }
+
+    // Fetch current pages
+    const [pageResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      dimensions: [{ name: 'unifiedScreenName' }],
+      metrics: [{ name: 'screenPageViews' }],
+      orderBy: [{ metric: { metricName: 'screenPageViews' }, desc: true }],
+      limit: 25
+    });
+
+    // Fetch events
+    const [eventResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      dimensions: [{ name: 'eventName' }],
+      metrics: [{ name: 'eventCount' }],
+      orderBy: [{ metric: { metricName: 'eventCount' }, desc: true }],
+      limit: 25
+    });
+
+    // Fetch device categories
+    const [deviceResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      dimensions: [{ name: 'deviceCategory' }],
+      metrics: [{ name: 'activeUsers' }],
+      orderBy: [{ metric: { metricName: 'activeUsers' }, desc: true }],
+      limit: 10,
+      returnPropertyQuota: true
+    });
+
+    const response = {
+      pageResponse,
+      eventResponse,
+      sourceResponse: deviceResponse
+    };
+
+    // Cache the response
+    await req.redisClient.set(cacheKey, JSON.stringify(response), {
+      EX: CACHE_DURATIONS.REALTIME_DETAILED
+    });
+
+    res.json({ success: true, data: response });
+  } catch (error) {
+    logger.error('Error fetching realtime detailed data:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// User behavior endpoint
+router.get('/user-behavior', async (req, res) => {
+  try {
+    const { timeRange = '30' } = req.query;
+    const cacheKey = `analytics:user_behavior:${timeRange}`;
+    
+    // Check Redis cache
+    const cachedData = await req.redisClient.get(cacheKey);
+    if (cachedData) {
+      logger.info('Returning cached user behavior data');
+      return res.json({ success: true, data: JSON.parse(cachedData) });
+    }
+
+    // Fetch page data
+    const [pageResponse] = await analyticsClient.runReport({
+      property: `properties/${propertyId}`,
+      dateRanges: [{ startDate: `${timeRange}daysAgo`, endDate: 'today' }],
+      dimensions: [{ name: 'pagePath' }],
+      metrics: [
+        { name: 'screenPageViews' },
+        { name: 'averageSessionDuration' },
+        { name: 'bounceRate' },
+        { name: 'sessions' }
+      ],
+      orderBy: [{
+        metric: { metricName: 'screenPageViews' },
+        desc: true
+      }],
+      limit: 25
+    });
+
+    // Fetch device data
+    const [deviceResponse] = await analyticsClient.runReport({
+      property: `properties/${propertyId}`,
+      dateRanges: [{ startDate: `${timeRange}daysAgo`, endDate: 'today' }],
+      dimensions: [{ name: 'deviceCategory' }],
+      metrics: [
+        { name: 'screenPageViews' },
+        { name: 'sessions' }
+      ]
+    });
+
+    // Fetch source data
+    const [sourceResponse] = await analyticsClient.runReport({
+      property: `properties/${propertyId}`,
+      dateRanges: [{ startDate: `${timeRange}daysAgo`, endDate: 'today' }],
+      dimensions: [{ name: 'sessionSource' }],
+      metrics: [
+        { name: 'sessions' },
+        { name: 'conversions' }
+      ],
+      orderBy: [{
+        metric: { metricName: 'sessions' },
+        desc: true
+      }],
+      limit: 25,
+      returnPropertyQuota: true
+    });
+
+    const response = {
+      pageResponse,
+      deviceResponse,
+      sourceResponse
+    };
+
+    // Cache the response
+    await req.redisClient.set(cacheKey, JSON.stringify(response), {
+      EX: CACHE_DURATIONS.USER_BEHAVIOR
+    });
+
+    res.json({ success: true, data: response });
+  } catch (error) {
+    logger.error('Error fetching user behavior data:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+module.exports = router; 

inventory-server/dashboard/google-server/routes/analytics.routes.js

@@ -0,0 +1,91 @@
+const express = require('express');
+const router = express.Router();
+const analyticsService = require('../services/analytics.service');
+
+// Basic metrics endpoint
+router.get('/metrics', async (req, res) => {
+  try {
+    const { startDate = '7daysAgo' } = req.query;
+    console.log(`Fetching metrics with startDate: ${startDate}`);
+    
+    const data = await analyticsService.getBasicMetrics(startDate);
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error('Metrics error:', {
+      startDate: req.query.startDate,
+      error: error.message,
+      stack: error.stack
+    });
+    
+    res.status(500).json({
+      success: false,
+      error: 'Failed to fetch metrics',
+      details: error.message
+    });
+  }
+});
+
+// Realtime basic data endpoint
+router.get('/realtime/basic', async (req, res) => {
+  try {
+    console.log('Fetching realtime basic data');
+    const data = await analyticsService.getRealTimeBasicData();
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error('Realtime basic error:', {
+      error: error.message,
+      stack: error.stack
+    });
+    
+    res.status(500).json({
+      success: false,
+      error: 'Failed to fetch realtime basic data',
+      details: error.message
+    });
+  }
+});
+
+// Realtime detailed data endpoint
+router.get('/realtime/detailed', async (req, res) => {
+  try {
+    console.log('Fetching realtime detailed data');
+    const data = await analyticsService.getRealTimeDetailedData();
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error('Realtime detailed error:', {
+      error: error.message,
+      stack: error.stack
+    });
+    
+    res.status(500).json({
+      success: false,
+      error: 'Failed to fetch realtime detailed data',
+      details: error.message
+    });
+  }
+});
+
+// User behavior endpoint
+router.get('/user-behavior', async (req, res) => {
+  try {
+    const { timeRange = '30' } = req.query;
+    console.log(`Fetching user behavior with timeRange: ${timeRange}`);
+    
+    const data = await analyticsService.getUserBehavior(timeRange);
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error('User behavior error:', {
+      timeRange: req.query.timeRange,
+      error: error.message,
+      stack: error.stack
+    });
+    
+    res.status(500).json({
+      success: false,
+      error: 'Failed to fetch user behavior data',
+      details: error.message
+    });
+  }
+});
+
+module.exports = router;