Overdue initial commit

dashboard-server/aircall-server/.env.example

@@ -0,0 +1,21 @@
+# Server Configuration
+NODE_ENV=development
+AIRCALL_PORT=3002
+LOG_LEVEL=info
+
+# Aircall API Credentials
+AIRCALL_API_ID=your_aircall_api_id
+AIRCALL_API_TOKEN=your_aircall_api_token
+
+# Database Configuration
+MONGODB_URI=mongodb://localhost:27017/dashboard
+MONGODB_DB=dashboard
+REDIS_URL=redis://localhost:6379
+
+# Service Configuration
+TIMEZONE=America/New_York
+DAY_STARTS_AT=1 # Business day starts at 1 AM ET
+
+# Optional Settings
+REDIS_TTL=300 # Cache TTL in seconds (5 minutes)
+COLLECTION_NAME=aircall_daily_data

dashboard-server/aircall-server/README.md

@@ -0,0 +1,55 @@
+# Aircall Server
+
+A standalone server for handling Aircall metrics and data processing.
+
+## Setup
+
+1. Install dependencies:
+```bash
+npm install
+```
+
+2. Set up environment variables:
+```bash
+cp .env.example .env
+```
+Then edit `.env` with your configuration.
+
+Required environment variables:
+- `AIRCALL_API_ID`: Your Aircall API ID
+- `AIRCALL_API_TOKEN`: Your Aircall API Token
+- `MONGODB_URI`: MongoDB connection string
+- `REDIS_URL`: Redis connection string
+- `AIRCALL_PORT`: Server port (default: 3002)
+
+## Running the Server
+
+### Development
+```bash
+npm run dev
+```
+
+### Production
+Using PM2:
+```bash
+pm2 start ecosystem.config.js --env production
+```
+
+## API Endpoints
+
+### GET /api/aircall/metrics/:timeRange
+Get Aircall metrics for a specific time range.
+
+Parameters:
+- `timeRange`: One of ['today', 'yesterday', 'last7days', 'last30days', 'last90days']
+
+### GET /api/aircall/health
+Get server health status.
+
+## Architecture
+
+The server uses:
+- Express.js for the API
+- MongoDB for data storage
+- Redis for caching
+- Winston for logging 

dashboard-server/aircall-server/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "aircall-server",
+  "version": "1.0.0",
+  "description": "Aircall metrics server",
+  "type": "module",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "dependencies": {
+    "axios": "^1.6.2",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "mongodb": "^6.3.0",
+    "redis": "^4.6.11",
+    "winston": "^3.11.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.2"
+  }
+} 

dashboard-server/aircall-server/server.js

@@ -0,0 +1,83 @@
+import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRoutes } from './src/routes/index.js';
+import { aircallConfig } from './src/config/aircall.config.js';
+import { connectMongoDB } from './src/utils/db.js';
+import { createRedisClient } from './src/utils/redis.js';
+import { createLogger } from './src/utils/logger.js';
+
+// Get directory name in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Load environment variables from the correct path
+dotenv.config({ path: path.resolve(__dirname, '.env') });
+
+// Validate required environment variables
+const requiredEnvVars = ['AIRCALL_API_ID', 'AIRCALL_API_TOKEN', 'MONGODB_URI', 'REDIS_URL'];
+const missingEnvVars = requiredEnvVars.filter(envVar => !process.env[envVar]);
+
+if (missingEnvVars.length > 0) {
+  console.error('Missing required environment variables:', missingEnvVars);
+  process.exit(1);
+}
+
+const app = express();
+const port = process.env.AIRCALL_PORT || 3002;
+const logger = createLogger('aircall-server');
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Connect to databases
+let mongodb;
+let redis;
+
+async function initializeServer() {
+  try {
+    // Connect to MongoDB
+    mongodb = await connectMongoDB();
+    logger.info('Connected to MongoDB');
+
+    // Connect to Redis
+    redis = await createRedisClient();
+    logger.info('Connected to Redis');
+
+    // Initialize configs with database connections
+    const configs = {
+      aircall: {
+        ...aircallConfig,
+        mongodb,
+        redis,
+        logger
+      }
+    };
+
+    // Initialize routes
+    const routes = createRoutes(configs, logger);
+    app.use('/api', routes);
+
+    // Error handling middleware
+    app.use((err, req, res, next) => {
+      logger.error('Server error:', err);
+      res.status(500).json({
+        error: 'Internal server error',
+        message: err.message
+      });
+    });
+
+    // Start server
+    app.listen(port, () => {
+      logger.info(`Aircall server listening on port ${port}`);
+    });
+  } catch (error) {
+    logger.error('Failed to initialize server:', error);
+    process.exit(1);
+  }
+}
+
+initializeServer(); 

dashboard-server/aircall-server/src/config/aircall.config.js

@@ -0,0 +1,15 @@
+export const aircallConfig = {
+  serviceName: 'aircall',
+  apiId: process.env.AIRCALL_API_ID,
+  apiToken: process.env.AIRCALL_API_TOKEN,
+  timezone: 'America/New_York',
+  dayStartsAt: 1,
+  storeHistory: true,
+  collection: 'aircall_daily_data',
+  redisTTL: 300, // 5 minutes cache for current day
+  endpoints: {
+    metrics: {
+      ttl: 300
+    }
+  }
+}; 

dashboard-server/aircall-server/src/routes/aircall.routes.js

@@ -0,0 +1,57 @@
+import express from 'express';
+import { AircallService } from '../services/aircall/AircallService.js';
+
+export const createAircallRoutes = (config, logger) => {
+  const router = express.Router();
+  const aircallService = new AircallService(config);
+
+  router.get('/metrics/:timeRange?', async (req, res) => {
+    try {
+      const { timeRange = 'today' } = req.params;
+      const allowedRanges = ['today', 'yesterday', 'last7days', 'last30days', 'last90days'];
+      
+      if (!allowedRanges.includes(timeRange)) {
+        return res.status(400).json({ 
+          error: 'Invalid time range',
+          allowedRanges 
+        });
+      }
+
+      const metrics = await aircallService.getMetrics(timeRange);
+      
+      res.json({
+        ...metrics,
+        _meta: {
+          timeRange,
+          generatedAt: new Date().toISOString(),
+          dataPoints: metrics.daily_data?.length || 0
+        }
+      });
+    } catch (error) {
+      logger.error('Error fetching Aircall metrics:', error);
+      res.status(500).json({ 
+        error: 'Failed to fetch Aircall metrics',
+        message: error.message 
+      });
+    }
+  });
+
+  // Health check endpoint
+  router.get('/health', (req, res) => {
+    const mongoConnected = !!aircallService.mongodb?.db;
+    const redisConnected = !!aircallService.redis?.isOpen;
+    
+    const health = {
+      status: mongoConnected && redisConnected ? 'ok' : 'degraded',
+      service: 'aircall',
+      timestamp: new Date().toISOString(),
+      connections: {
+        mongodb: mongoConnected,
+        redis: redisConnected
+      }
+    };
+    res.json(health);
+  });
+
+  return router;
+}; 

dashboard-server/aircall-server/src/routes/index.js

@@ -0,0 +1,32 @@
+import express from 'express';
+import { createAircallRoutes } from './aircall.routes.js';
+
+export const createRoutes = (configs, logger) => {
+  const router = express.Router();
+  
+  // Mount Aircall routes
+  router.use('/aircall', createAircallRoutes(configs.aircall, logger));
+
+  // Health check endpoint
+  router.get('/health', (req, res) => {
+    const services = req.services || {};
+    res.status(200).json({
+      status: 'ok',
+      timestamp: new Date(),
+      services: {
+        redis: services.redis?.isReady || false,
+        mongodb: services.mongo?.readyState === 1 || false
+      }
+    });
+  });
+
+  // Catch-all 404 handler
+  router.use('*', (req, res) => {
+    res.status(404).json({
+      error: 'Not Found',
+      message: `Route ${req.originalUrl} not found`
+    });
+  });
+
+  return router;
+}; 

dashboard-server/aircall-server/src/services/aircall/AircallDataManager.js

@@ -0,0 +1,298 @@
+import { DataManager } from "../base/DataManager.js";
+
+export class AircallDataManager extends DataManager {
+  constructor(mongodb, redis, timeManager) {
+    const options = {
+      collection: "aircall_daily_data",
+      redisTTL: 300 // 5 minutes cache
+    };
+    super(mongodb, redis, timeManager, options);
+    this.options = options;
+  }
+
+  ensureDate(d) {
+    if (d instanceof Date) return d;
+    if (typeof d === 'string') return new Date(d);
+    if (typeof d === 'number') return new Date(d);
+    console.error('Invalid date value:', d);
+    return new Date(); // fallback to current date
+  }
+
+  async storeHistoricalPeriod(start, end, calls) {
+    if (!this.mongodb) return;
+  
+    try {
+      if (!Array.isArray(calls)) {
+        console.error("Invalid calls data:", calls);
+        return;
+      }
+  
+      // Group calls by true day boundaries using TimeManager
+      const dailyCallsMap = new Map();
+  
+      calls.forEach((call) => {
+        try {
+          const timestamp = call.started_at * 1000; // Convert to milliseconds
+          const callDate = this.ensureDate(timestamp);
+          const dayBounds = this.timeManager.getDayBounds(callDate);
+          const dayKey = dayBounds.start.toISOString();
+          
+          if (!dailyCallsMap.has(dayKey)) {
+            dailyCallsMap.set(dayKey, {
+              date: dayBounds.start,
+              calls: [],
+            });
+          }
+          dailyCallsMap.get(dayKey).calls.push(call);
+        } catch (err) {
+          console.error('Error processing call:', err, call);
+        }
+      });
+  
+      // Iterate over each day in the period using day boundaries
+      const dates = [];
+      let currentDate = this.ensureDate(start);
+      const endDate = this.ensureDate(end);
+      
+      while (currentDate < endDate) {
+        const dayBounds = this.timeManager.getDayBounds(currentDate);
+        dates.push(dayBounds.start);
+        currentDate.setUTCDate(currentDate.getUTCDate() + 1);
+      }
+  
+      for (const date of dates) {
+        try {
+          const dateKey = date.toISOString();
+          const dayData = dailyCallsMap.get(dateKey);
+          const dayCalls = dayData ? dayData.calls : [];
+    
+          // Process calls for this day using the same processing logic
+          const metrics = this.processCallData(dayCalls);
+    
+          // Insert a daily_data record for this day
+          metrics.daily_data = [
+            {
+              date: date.toISOString().split("T")[0],
+              inbound: metrics.by_direction.inbound,
+              outbound: metrics.by_direction.outbound,
+            },
+          ];
+    
+          // Store this day's processed data as historical
+          await this.storeHistoricalDay(date, metrics);
+        } catch (err) {
+          console.error('Error processing date:', err, date);
+        }
+      }
+  
+    } catch (error) {
+      console.error("Error storing historical period:", error, error.stack);
+      throw error;
+    }
+  }
+
+  processCallData(calls) {
+    // If calls is already processed (has total, by_direction, etc.), return it
+    if (calls && calls.total !== undefined) {
+      console.log('Data already processed:', {
+        total: calls.total,
+        by_direction: calls.by_direction
+      });
+      // Return a clean copy of the processed data
+      return {
+        total: calls.total,
+        by_direction: calls.by_direction,
+        by_status: calls.by_status,
+        by_missed_reason: calls.by_missed_reason,
+        by_hour: calls.by_hour,
+        by_users: calls.by_users,
+        daily_data: calls.daily_data,
+        duration_distribution: calls.duration_distribution,
+        average_duration: calls.average_duration
+      };
+    }
+
+    console.log('Processing raw calls:', {
+      count: calls.length,
+      sample: calls.length > 0 ? {
+        id: calls[0].id,
+        direction: calls[0].direction,
+        status: calls[0].status
+      } : null
+    });
+
+    // Process raw calls
+    const metrics = {
+      total: calls.length,
+      by_direction: { inbound: 0, outbound: 0 },
+      by_status: { answered: 0, missed: 0 },
+      by_missed_reason: {},
+      by_hour: Array(24).fill(0),
+      by_users: {},
+      daily_data: [],
+      duration_distribution: [
+        { range: "0-1m", count: 0 },
+        { range: "1-5m", count: 0 },
+        { range: "5-15m", count: 0 },
+        { range: "15-30m", count: 0 },
+        { range: "30m+", count: 0 },
+      ],
+      average_duration: 0,
+      total_duration: 0,
+    };
+
+    // Group calls by date for daily data
+    const dailyCallsMap = new Map();
+
+    calls.forEach((call) => {
+      try {
+        // Direction metrics
+        metrics.by_direction[call.direction]++;
+
+        // Get call date and hour using TimeManager
+        const timestamp = call.started_at * 1000; // Convert to milliseconds
+        const callDate = this.ensureDate(timestamp);
+        const dayBounds = this.timeManager.getDayBounds(callDate);
+        const dayKey = dayBounds.start.toISOString().split("T")[0];
+        const hour = callDate.getHours();
+        metrics.by_hour[hour]++;
+
+        // Status and duration metrics
+        if (call.answered_at) {
+          metrics.by_status.answered++;
+          const duration = call.ended_at - call.answered_at;
+          metrics.total_duration += duration;
+
+          // Duration distribution
+          if (duration <= 60) {
+            metrics.duration_distribution[0].count++;
+          } else if (duration <= 300) {
+            metrics.duration_distribution[1].count++;
+          } else if (duration <= 900) {
+            metrics.duration_distribution[2].count++;
+          } else if (duration <= 1800) {
+            metrics.duration_distribution[3].count++;
+          } else {
+            metrics.duration_distribution[4].count++;
+          }
+
+          // Track user performance
+          if (call.user) {
+            const userId = call.user.id;
+            if (!metrics.by_users[userId]) {
+              metrics.by_users[userId] = {
+                id: userId,
+                name: call.user.name,
+                total: 0,
+                answered: 0,
+                missed: 0,
+                total_duration: 0,
+                average_duration: 0,
+              };
+            }
+            metrics.by_users[userId].total++;
+            metrics.by_users[userId].answered++;
+            metrics.by_users[userId].total_duration += duration;
+          }
+        } else {
+          metrics.by_status.missed++;
+          if (call.missed_call_reason) {
+            metrics.by_missed_reason[call.missed_call_reason] =
+              (metrics.by_missed_reason[call.missed_call_reason] || 0) + 1;
+          }
+
+          // Track missed calls by user
+          if (call.user) {
+            const userId = call.user.id;
+            if (!metrics.by_users[userId]) {
+              metrics.by_users[userId] = {
+                id: userId,
+                name: call.user.name,
+                total: 0,
+                answered: 0,
+                missed: 0,
+                total_duration: 0,
+                average_duration: 0,
+              };
+            }
+            metrics.by_users[userId].total++;
+            metrics.by_users[userId].missed++;
+          }
+        }
+
+        // Group by date for daily data
+        if (!dailyCallsMap.has(dayKey)) {
+          dailyCallsMap.set(dayKey, { date: dayKey, inbound: 0, outbound: 0 });
+        }
+        dailyCallsMap.get(dayKey)[call.direction]++;
+      } catch (err) {
+        console.error('Error processing call:', err, call);
+      }
+    });
+
+    // Calculate average durations for users
+    Object.values(metrics.by_users).forEach((user) => {
+      if (user.answered > 0) {
+        user.average_duration = Math.round(user.total_duration / user.answered);
+      }
+    });
+
+    // Calculate global average duration
+    if (metrics.by_status.answered > 0) {
+      metrics.average_duration = Math.round(
+        metrics.total_duration / metrics.by_status.answered
+      );
+    }
+
+    // Convert daily data map to sorted array
+    metrics.daily_data = Array.from(dailyCallsMap.values()).sort((a, b) =>
+      a.date.localeCompare(b.date)
+    );
+
+    delete metrics.total_duration;
+
+    console.log('Processed metrics:', {
+      total: metrics.total,
+      by_direction: metrics.by_direction,
+      by_status: metrics.by_status,
+      daily_data_count: metrics.daily_data.length
+    });
+
+    return metrics;
+  }
+
+  async storeHistoricalDay(date, data) {
+    if (!this.mongodb) return;
+
+    try {
+      const collection = this.mongodb.collection(this.options.collection);
+      const dayBounds = this.timeManager.getDayBounds(this.ensureDate(date));
+
+      // Ensure consistent data structure with metrics nested in data field
+      const document = {
+        date: dayBounds.start,
+        data: {
+          total: data.total,
+          by_direction: data.by_direction,
+          by_status: data.by_status,
+          by_missed_reason: data.by_missed_reason,
+          by_hour: data.by_hour,
+          by_users: data.by_users,
+          daily_data: data.daily_data,
+          duration_distribution: data.duration_distribution,
+          average_duration: data.average_duration
+        },
+        updatedAt: new Date()
+      };
+
+      await collection.updateOne(
+        { date: dayBounds.start },
+        { $set: document },
+        { upsert: true }
+      );
+    } catch (error) {
+      console.error("Error storing historical day:", error);
+      throw error;
+    }
+  }
+}

dashboard-server/aircall-server/src/services/aircall/AircallService.js

@@ -0,0 +1,138 @@
+import axios from "axios";
+import { Buffer } from "buffer";
+import { BaseService } from "../base/BaseService.js";
+import { AircallDataManager } from "./AircallDataManager.js";
+
+export class AircallService extends BaseService {
+  constructor(config) {
+    super(config);
+    this.baseUrl = "https://api.aircall.io/v1";
+    console.log('Initializing Aircall service with credentials:', {
+      apiId: config.apiId ? 'present' : 'missing',
+      apiToken: config.apiToken ? 'present' : 'missing'
+    });
+    this.auth = Buffer.from(`${config.apiId}:${config.apiToken}`).toString(
+      "base64"
+    );
+    this.dataManager = new AircallDataManager(
+      this.mongodb,
+      this.redis,
+      this.timeManager
+    );
+
+    if (!config.apiId || !config.apiToken) {
+      throw new Error("Aircall API credentials are required");
+    }
+  }
+
+  async getMetrics(timeRange) {
+    const dateRange = await this.timeManager.getDateRange(timeRange);
+    console.log('Fetching metrics for date range:', {
+      start: dateRange.start.toISOString(),
+      end: dateRange.end.toISOString()
+    });
+
+    return this.dataManager.getData(dateRange, async (range) => {
+      const calls = await this.fetchAllCalls(range.start, range.end);
+      console.log('Fetched calls:', {
+        count: calls.length,
+        sample: calls.length > 0 ? calls[0] : null
+      });
+      return calls;
+    });
+  }
+
+  async fetchAllCalls(start, end) {
+    try {
+      let allCalls = [];
+      let currentPage = 1;
+      let hasMore = true;
+      let totalPages = null;
+
+      while (hasMore) {
+        const response = await this.makeRequest("/calls", {
+          from: Math.floor(start.getTime() / 1000),
+          to: Math.floor(end.getTime() / 1000),
+          order: "asc",
+          page: currentPage,
+          per_page: 50,
+        });
+
+        console.log('API Response:', {
+          page: currentPage,
+          totalPages: response.meta.total_pages,
+          callsCount: response.calls?.length,
+          params: {
+            from: Math.floor(start.getTime() / 1000),
+            to: Math.floor(end.getTime() / 1000)
+          }
+        });
+
+        if (!response.calls) {
+          throw new Error("Invalid API response format");
+        }
+
+        allCalls = [...allCalls, ...response.calls];
+        hasMore = response.meta.next_page_link !== null;
+        totalPages = response.meta.total_pages;
+        currentPage++;
+
+        if (hasMore) {
+          // Rate limiting pause
+          await new Promise((resolve) => setTimeout(resolve, 1));
+        }
+      }
+
+      return allCalls;
+    } catch (error) {
+      console.error("Error fetching all calls:", error);
+      throw error;
+    }
+  }
+
+  async makeRequest(endpoint, params = {}) {
+    try {
+      console.log('Making API request:', {
+        endpoint,
+        params
+      });
+      const response = await axios.get(`${this.baseUrl}${endpoint}`, {
+        headers: {
+          Authorization: `Basic ${this.auth}`,
+          "Content-Type": "application/json",
+        },
+        params,
+      });
+      return response.data;
+    } catch (error) {
+      if (error.response?.status === 429) {
+        console.log("Rate limit reached, waiting before retry...");
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+        return this.makeRequest(endpoint, params);
+      }
+
+      this.handleApiError(error, `Error making request to ${endpoint}`);
+    }
+  }
+
+  validateApiResponse(response, context = "") {
+    if (!response || typeof response !== "object") {
+      throw new Error(`${context}: Invalid API response format`);
+    }
+
+    if (response.error) {
+      throw new Error(`${context}: ${response.error}`);
+    }
+
+    return true;
+  }
+
+  getPaginationInfo(meta) {
+    return {
+      currentPage: meta.current_page,
+      totalPages: meta.total_pages,
+      hasNextPage: meta.next_page_link !== null,
+      totalRecords: meta.total,
+    };
+  }
+} 

dashboard-server/aircall-server/src/services/base/BaseService.js

@@ -0,0 +1,32 @@
+import { createTimeManager } from '../../utils/timeUtils.js';
+
+export class BaseService {
+  constructor(config) {
+    this.config = config;
+    this.mongodb = config.mongodb;
+    this.redis = config.redis;
+    this.logger = config.logger;
+    this.timeManager = createTimeManager(config.timezone, config.dayStartsAt);
+  }
+
+  handleApiError(error, context = '') {
+    this.logger.error(`API Error ${context}:`, {
+      message: error.message,
+      status: error.response?.status,
+      data: error.response?.data,
+    });
+
+    if (error.response) {
+      const status = error.response.status;
+      const message = error.response.data?.message || error.response.statusText;
+
+      if (status === 429) {
+        throw new Error('API rate limit exceeded. Please try again later.');
+      }
+
+      throw new Error(`API error (${status}): ${message}`);
+    }
+
+    throw error;
+  }
+} 

dashboard-server/aircall-server/src/services/base/DataManager.js

@@ -0,0 +1,320 @@
+export class DataManager {
+  constructor(mongodb, redis, timeManager, options) {
+    this.mongodb = mongodb;
+    this.redis = redis;
+    this.timeManager = timeManager;
+    this.options = options || {};
+  }
+
+  ensureDate(d) {
+    if (d instanceof Date) return d;
+    if (typeof d === 'string') return new Date(d);
+    if (typeof d === 'number') return new Date(d);
+    if (d && d.date) return new Date(d.date); // Handle MongoDB records
+    console.error('Invalid date value:', d);
+    return new Date(); // fallback to current date
+  }
+
+  async getData(dateRange, fetchFn) {
+    try {
+      // Get historical data from MongoDB
+      const historicalData = await this.getHistoricalDays(dateRange.start, dateRange.end);
+      
+      // Find any missing date ranges
+      const missingRanges = this.findMissingDateRanges(dateRange.start, dateRange.end, historicalData);
+
+      // Fetch missing data
+      for (const range of missingRanges) {
+        const data = await fetchFn(range);
+        await this.storeHistoricalPeriod(range.start, range.end, data);
+      }
+
+      // Get updated historical data
+      const updatedData = await this.getHistoricalDays(dateRange.start, dateRange.end);
+      
+      // Handle both nested and flat data structures
+      if (updatedData && updatedData.length > 0) {
+        // Process each record and combine them
+        const processedData = updatedData.map(record => {
+          if (record.data) {
+            return record.data;
+          }
+          if (record.total !== undefined) {
+            return {
+              total: record.total,
+              by_direction: record.by_direction,
+              by_status: record.by_status,
+              by_missed_reason: record.by_missed_reason,
+              by_hour: record.by_hour,
+              by_users: record.by_users,
+              daily_data: record.daily_data,
+              duration_distribution: record.duration_distribution,
+              average_duration: record.average_duration
+            };
+          }
+          return null;
+        }).filter(Boolean);
+
+        // Combine the data
+        if (processedData.length > 0) {
+          return this.combineMetrics(processedData);
+        }
+      }
+      
+      // Otherwise process as raw call data
+      return this.processCallData(updatedData);
+    } catch (error) {
+      console.error('Error in getData:', error);
+      throw error;
+    }
+  }
+
+  findMissingDateRanges(start, end, existingDates) {
+    const missingRanges = [];
+    const existingDatesSet = new Set(
+      existingDates.map((d) => {
+        // Handle both nested and flat data structures
+        const date = d.date ? d.date : d;
+        return this.ensureDate(date).toISOString().split("T")[0];
+      })
+    );
+
+    let current = new Date(start);
+    const endDate = new Date(end);
+    
+    while (current < endDate) {
+      const dayBounds = this.timeManager.getDayBounds(current);
+      const dayKey = dayBounds.start.toISOString().split("T")[0];
+
+      if (!existingDatesSet.has(dayKey)) {
+        // Found a missing day
+        const missingStart = new Date(dayBounds.start);
+        const missingEnd = new Date(dayBounds.end);
+
+        missingRanges.push({
+          start: missingStart,
+          end: missingEnd,
+        });
+      }
+
+      // Move to the next day using timeManager to ensure proper business day boundaries
+      current = new Date(dayBounds.end.getTime() + 1);
+    }
+
+    return missingRanges;
+  }
+
+  async getCurrentDay(fetchFn) {
+    const now = new Date();
+    const todayBounds = this.timeManager.getDayBounds(now);
+    const todayKey = this.timeManager.formatDate(todayBounds.start);
+    const cacheKey = `${this.options.collection}:current_day:${todayKey}`;
+
+    try {
+      // Check cache first
+      if (this.redis?.isOpen) {
+        const cached = await this.redis.get(cacheKey);
+        if (cached) {
+          const parsedCache = JSON.parse(cached);
+          if (parsedCache.total !== undefined) {
+            // Use timeManager to check if the cached data is for today
+            const cachedDate = new Date(parsedCache.daily_data[0].date);
+            const isToday = this.timeManager.isToday(cachedDate);
+            
+            if (isToday) {
+              return parsedCache;
+            }
+          }
+        }
+      }
+
+      // Get safe end time that's never in the future
+      const safeEnd = this.timeManager.getCurrentBusinessDayEnd();
+
+      // Fetch and process current day data with safe end time
+      const data = await fetchFn({
+        start: todayBounds.start,
+        end: safeEnd
+      });
+
+      if (!data) {
+        return null;
+      }
+
+      // Cache the data with a shorter TTL for today's data
+      if (this.redis?.isOpen) {
+        const ttl = Math.min(
+          this.options.redisTTL,
+          60 * 5 // 5 minutes max for today's data
+        );
+        await this.redis.set(cacheKey, JSON.stringify(data), {
+          EX: ttl,
+        });
+      }
+
+      return data;
+    } catch (error) {
+      console.error('Error in getCurrentDay:', error);
+      throw error;
+    }
+  }
+
+  getDayCount(start, end) {
+    // Calculate full days between dates using timeManager
+    const startDay = this.timeManager.getDayBounds(start);
+    const endDay = this.timeManager.getDayBounds(end);
+    return Math.ceil((endDay.end - startDay.start) / (24 * 60 * 60 * 1000));
+  }
+
+  async fetchMissingDays(start, end, existingData, fetchFn) {
+    const existingDates = new Set(
+      existingData.map((d) => this.timeManager.formatDate(d.date))
+    );
+    const missingData = [];
+
+    let currentDate = new Date(start);
+    while (currentDate < end) {
+      const dayBounds = this.timeManager.getDayBounds(currentDate);
+      const dateString = this.timeManager.formatDate(dayBounds.start);
+      
+      if (!existingDates.has(dateString)) {
+        const data = await fetchFn({
+          start: dayBounds.start,
+          end: dayBounds.end,
+        });
+
+        await this.storeHistoricalDay(dayBounds.start, data);
+        missingData.push(data);
+      }
+
+      // Move to next day using timeManager to ensure proper business day boundaries
+      currentDate = new Date(dayBounds.end.getTime() + 1);
+    }
+
+    return missingData;
+  }
+
+  async getHistoricalDays(start, end) {
+    try {
+      if (!this.mongodb) return [];
+
+      const collection = this.mongodb.collection(this.options.collection);
+      const startDay = this.timeManager.getDayBounds(start);
+      const endDay = this.timeManager.getDayBounds(end);
+
+      const records = await collection
+        .find({
+          date: {
+            $gte: startDay.start,
+            $lt: endDay.start,
+          },
+        })
+        .sort({ date: 1 })
+        .toArray();
+
+      return records;
+    } catch (error) {
+      console.error('Error getting historical days:', error);
+      return [];
+    }
+  }
+
+  combineMetrics(metricsArray) {
+    if (!metricsArray || metricsArray.length === 0) return null;
+    if (metricsArray.length === 1) return metricsArray[0];
+
+    const combined = {
+      total: 0,
+      by_direction: { inbound: 0, outbound: 0 },
+      by_status: { answered: 0, missed: 0 },
+      by_missed_reason: {},
+      by_hour: Array(24).fill(0),
+      by_users: {},
+      daily_data: [],
+      duration_distribution: [
+        { range: '0-1m', count: 0 },
+        { range: '1-5m', count: 0 },
+        { range: '5-15m', count: 0 },
+        { range: '15-30m', count: 0 },
+        { range: '30m+', count: 0 }
+      ],
+      average_duration: 0
+    };
+
+    let totalAnswered = 0;
+    let totalDuration = 0;
+
+    metricsArray.forEach(metrics => {
+      // Sum basic metrics
+      combined.total += metrics.total;
+      combined.by_direction.inbound += metrics.by_direction.inbound;
+      combined.by_direction.outbound += metrics.by_direction.outbound;
+      combined.by_status.answered += metrics.by_status.answered;
+      combined.by_status.missed += metrics.by_status.missed;
+
+      // Combine missed reasons
+      Object.entries(metrics.by_missed_reason).forEach(([reason, count]) => {
+        combined.by_missed_reason[reason] = (combined.by_missed_reason[reason] || 0) + count;
+      });
+
+      // Sum hourly data
+      metrics.by_hour.forEach((count, hour) => {
+        combined.by_hour[hour] += count;
+      });
+
+      // Combine user data
+      Object.entries(metrics.by_users).forEach(([userId, userData]) => {
+        if (!combined.by_users[userId]) {
+          combined.by_users[userId] = {
+            id: userData.id,
+            name: userData.name,
+            total: 0,
+            answered: 0,
+            missed: 0,
+            total_duration: 0,
+            average_duration: 0
+          };
+        }
+        combined.by_users[userId].total += userData.total;
+        combined.by_users[userId].answered += userData.answered;
+        combined.by_users[userId].missed += userData.missed;
+        combined.by_users[userId].total_duration += userData.total_duration || 0;
+      });
+
+      // Combine duration distribution
+      metrics.duration_distribution.forEach((dist, index) => {
+        combined.duration_distribution[index].count += dist.count;
+      });
+
+      // Accumulate for average duration calculation
+      if (metrics.average_duration && metrics.by_status.answered) {
+        totalDuration += metrics.average_duration * metrics.by_status.answered;
+        totalAnswered += metrics.by_status.answered;
+      }
+
+      // Merge daily data
+      if (metrics.daily_data) {
+        combined.daily_data.push(...metrics.daily_data);
+      }
+    });
+
+    // Calculate final average duration
+    if (totalAnswered > 0) {
+      combined.average_duration = Math.round(totalDuration / totalAnswered);
+    }
+
+    // Calculate user averages
+    Object.values(combined.by_users).forEach(user => {
+      if (user.answered > 0) {
+        user.average_duration = Math.round(user.total_duration / user.answered);
+      }
+    });
+
+    // Sort and deduplicate daily data
+    combined.daily_data = Array.from(
+      new Map(combined.daily_data.map(item => [item.date, item])).values()
+    ).sort((a, b) => a.date.localeCompare(b.date));
+
+    return combined;
+  }
+} 

dashboard-server/aircall-server/src/utils/db.js

@@ -0,0 +1,15 @@
+import { MongoClient } from 'mongodb';
+
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/dashboard';
+const DB_NAME = process.env.MONGODB_DB || 'dashboard';
+
+export async function connectMongoDB() {
+  try {
+    const client = await MongoClient.connect(MONGODB_URI);
+    console.log('Connected to MongoDB');
+    return client.db(DB_NAME);
+  } catch (error) {
+    console.error('MongoDB connection error:', error);
+    throw error;
+  }
+} 

dashboard-server/aircall-server/src/utils/logger.js

@@ -0,0 +1,30 @@
+import winston from 'winston';
+import path from 'path';
+
+export function createLogger(service) {
+  return winston.createLogger({
+    level: process.env.LOG_LEVEL || 'info',
+    format: winston.format.combine(
+      winston.format.timestamp(),
+      winston.format.json()
+    ),
+    defaultMeta: { service },
+    transports: [
+      // Write all logs to console
+      new winston.transports.Console({
+        format: winston.format.combine(
+          winston.format.colorize(),
+          winston.format.simple()
+        )
+      }),
+      // Write all logs to service-specific files
+      new winston.transports.File({
+        filename: path.join('logs', `${service}-error.log`),
+        level: 'error'
+      }),
+      new winston.transports.File({
+        filename: path.join('logs', `${service}-combined.log`)
+      })
+    ]
+  });
+} 

dashboard-server/aircall-server/src/utils/redis.js

@@ -0,0 +1,23 @@
+import { createClient } from 'redis';
+
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+
+export async function createRedisClient() {
+  try {
+    const client = createClient({
+      url: REDIS_URL
+    });
+
+    await client.connect();
+    console.log('Connected to Redis');
+    
+    client.on('error', (err) => {
+      console.error('Redis error:', err);
+    });
+
+    return client;
+  } catch (error) {
+    console.error('Redis connection error:', error);
+    throw error;
+  }
+} 

dashboard-server/aircall-server/src/utils/timeUtils.js

@@ -0,0 +1,262 @@
+class TimeManager {
+  static ALLOWED_RANGES = ['today', 'yesterday', 'last2days', 'last7days', 'last30days', 'last90days', 
+                          'previous7days', 'previous30days', 'previous90days'];
+
+  constructor(timezone = 'America/New_York', dayStartsAt = 1) {
+    this.timezone = timezone;
+    this.dayStartsAt = dayStartsAt;
+  }
+
+  getDayBounds(date) {
+    try {
+      const now = new Date();
+      const targetDate = new Date(date);
+      
+      // For today
+      if (
+        targetDate.getUTCFullYear() === now.getUTCFullYear() &&
+        targetDate.getUTCMonth() === now.getUTCMonth() &&
+        targetDate.getUTCDate() === now.getUTCDate()
+      ) {
+        // If current time is before day start (1 AM ET / 6 AM UTC), 
+        // use previous day's start until now
+        const todayStart = new Date(Date.UTC(
+          now.getUTCFullYear(),
+          now.getUTCMonth(),
+          now.getUTCDate(),
+          this.dayStartsAt + 5,
+          0,
+          0,
+          0
+        ));
+  
+        if (now < todayStart) {
+          const yesterdayStart = new Date(todayStart);
+          yesterdayStart.setUTCDate(yesterdayStart.getUTCDate() - 1);
+          return { start: yesterdayStart, end: now };
+        }
+  
+        return { start: todayStart, end: now };
+      }
+  
+      // For past days, use full 24-hour period
+      const normalizedDate = new Date(Date.UTC(
+        targetDate.getUTCFullYear(),
+        targetDate.getUTCMonth(),
+        targetDate.getUTCDate()
+      ));
+
+      const dayStart = new Date(normalizedDate);
+      dayStart.setUTCHours(this.dayStartsAt + 5, 0, 0, 0);
+
+      const dayEnd = new Date(dayStart);
+      dayEnd.setUTCDate(dayEnd.getUTCDate() + 1);
+
+      return { start: dayStart, end: dayEnd };
+    } catch (error) {
+      console.error('Error in getDayBounds:', error);
+      throw new Error(`Failed to calculate day bounds: ${error.message}`);
+    }
+  }
+
+  getDateRange(period) {
+    try {
+      const now = new Date();
+      const todayBounds = this.getDayBounds(now);
+      const end = new Date();
+
+      switch (period) {
+        case 'today':
+          return {
+            start: todayBounds.start,
+            end
+          };
+        case 'yesterday': {
+          const yesterday = new Date(now);
+          yesterday.setDate(yesterday.getDate() - 1);
+          return this.getDayBounds(yesterday);
+        }
+        case 'last2days': {
+          const twoDaysAgo = new Date(now);
+          twoDaysAgo.setDate(twoDaysAgo.getDate() - 2);
+          return this.getDayBounds(twoDaysAgo);
+        }
+        case 'last7days': {
+          const start = new Date(now);
+          start.setDate(start.getDate() - 6);
+          return {
+            start: this.getDayBounds(start).start,
+            end
+          };
+        }
+        case 'previous7days': {
+          const end = new Date(now);
+          end.setDate(end.getDate() - 7);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 6);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        case 'last30days': {
+          const start = new Date(now);
+          start.setDate(start.getDate() - 29);
+          return {
+            start: this.getDayBounds(start).start,
+            end
+          };
+        }
+        case 'previous30days': {
+          const end = new Date(now);
+          end.setDate(end.getDate() - 30);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 29);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        case 'last90days': {
+          const start = new Date(now);
+          start.setDate(start.getDate() - 89);
+          return {
+            start: this.getDayBounds(start).start,
+            end
+          };
+        }
+        case 'previous90days': {
+          const end = new Date(now);
+          end.setDate(end.getDate() - 90);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 89);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        default:
+          throw new Error(`Unsupported time period: ${period}`);
+      }
+    } catch (error) {
+      console.error('Error in getDateRange:', error);
+      throw error;
+    }
+  }
+
+  getPreviousPeriod(period) {
+    try {
+      const now = new Date();
+      
+      switch (period) {
+        case 'today': 
+          return 'yesterday';
+        case 'yesterday': {
+          // Return bounds for 2 days ago
+          const twoDaysAgo = new Date(now);
+          twoDaysAgo.setDate(twoDaysAgo.getDate() - 2);
+          return this.getDayBounds(twoDaysAgo);
+        }
+        case 'last7days': {
+          // Return bounds for previous 7 days
+          const end = new Date(now);
+          end.setDate(end.getDate() - 7);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 7);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        case 'last30days': {
+          const end = new Date(now);
+          end.setDate(end.getDate() - 30);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 30);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        case 'last90days': {
+          const end = new Date(now);
+          end.setDate(end.getDate() - 90);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 90);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        default:
+          throw new Error(`Unsupported time period: ${period}`);
+      }
+    } catch (error) {
+      console.error('Error in getPreviousPeriod:', error);
+      throw error;
+    }
+  }
+
+  getCurrentBusinessDayEnd() {
+    try {
+      const now = new Date();
+      const todayBounds = this.getDayBounds(now);
+      
+      // If current time is before day start (1 AM ET / 6 AM UTC),
+      // then we're still in yesterday's business day
+      const todayStart = new Date(Date.UTC(
+        now.getUTCFullYear(),
+        now.getUTCMonth(),
+        now.getUTCDate(),
+        this.dayStartsAt + 5,
+        0,
+        0,
+        0
+      ));
+
+      if (now < todayStart) {
+        const yesterdayBounds = this.getDayBounds(new Date(now.getTime() - 24 * 60 * 60 * 1000));
+        return yesterdayBounds.end;
+      }
+
+      // Return the earlier of current time or today's end
+      return now < todayBounds.end ? now : todayBounds.end;
+    } catch (error) {
+      console.error('Error in getCurrentBusinessDayEnd:', error);
+      return new Date();
+    }
+  }
+
+  isValidTimeRange(timeRange) {
+    return TimeManager.ALLOWED_RANGES.includes(timeRange);
+  }
+
+  isToday(date) {
+    const now = new Date();
+    const targetDate = new Date(date);
+    return (
+      targetDate.getUTCFullYear() === now.getUTCFullYear() &&
+      targetDate.getUTCMonth() === now.getUTCMonth() &&
+      targetDate.getUTCDate() === now.getUTCDate()
+    );
+  }
+
+  formatDate(date) {
+    try {
+      return date.toLocaleString('en-US', {
+        timeZone: this.timezone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit'
+      });
+    } catch (error) {
+      console.error('Error formatting date:', error);
+      return date.toISOString();
+    }
+  }
+}
+
+export const createTimeManager = (timezone, dayStartsAt) => new TimeManager(timezone, dayStartsAt);