@jagilber-org/index-server 1.19.1

package/dist/dashboard/export/DataExporter.js

@@ -0,0 +1,737 @@
+"use strict";
+/**
+ * DataExporter - Phase 4 Advanced Data Export & Reporting System
+ *
+ * Comprehensive data export capabilities:
+ * - Multiple format support (JSON, CSV, Excel, PDF)
+ * - Scheduled reporting
+ * - Custom report templates
+ * - Data filtering and aggregation
+ * - Real-time streaming exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataExporter = void 0;
+const jsonExporter_js_1 = require("./exporters/jsonExporter.js");
+const csvExporter_js_1 = require("./exporters/csvExporter.js");
+const xmlExporter_js_1 = require("./exporters/xmlExporter.js");
+class DataExporter {
+    exportConfigs = new Map();
+    exportJobs = new Map();
+    reportTemplates = new Map();
+    scheduledJobs = new Map();
+    jobCallbacks = [];
+    constructor() {
+        this.initializeDefaultTemplates();
+        this.initializeDefaultConfigs();
+        this.startScheduler();
+    }
+    /**
+     * Initialize default report templates
+     */
+    initializeDefaultTemplates() {
+        const defaultTemplates = [
+            {
+                id: 'daily_summary',
+                name: 'Daily Summary Report',
+                description: 'Comprehensive daily system summary with key metrics',
+                type: 'dashboard_summary',
+                sections: [
+                    {
+                        id: 'overview',
+                        title: 'System Overview',
+                        type: 'metrics',
+                        dataSource: 'system_health',
+                        config: { period: '24h' },
+                        order: 1
+                    },
+                    {
+                        id: 'security_alerts',
+                        title: 'Security Alerts',
+                        type: 'table',
+                        dataSource: 'security_threats',
+                        config: { severity: ['high', 'critical'] },
+                        order: 2
+                    },
+                    {
+                        id: 'performance_chart',
+                        title: 'Performance Trends',
+                        type: 'chart',
+                        dataSource: 'performance_metrics',
+                        config: { chartType: 'line', metrics: ['cpu', 'memory', 'api_latency'] },
+                        order: 3
+                    }
+                ],
+                formatting: {
+                    pageSize: 'A4',
+                    orientation: 'portrait',
+                    margins: { top: 20, right: 20, bottom: 20, left: 20 },
+                    fontSize: 12,
+                    fontFamily: 'Arial',
+                    includeHeader: true,
+                    includeFooter: true,
+                    headerText: 'Index Server - Daily Report',
+                    footerText: 'Generated on {{date}} | Page {{page}}'
+                }
+            },
+            {
+                id: 'security_analysis',
+                name: 'Security Analysis Report',
+                description: 'Detailed security analysis with threat patterns and recommendations',
+                type: 'security_report',
+                sections: [
+                    {
+                        id: 'threat_summary',
+                        title: 'Threat Summary',
+                        type: 'metrics',
+                        dataSource: 'threat_statistics',
+                        config: { period: '7d' },
+                        order: 1
+                    },
+                    {
+                        id: 'threat_timeline',
+                        title: 'Threat Timeline',
+                        type: 'chart',
+                        dataSource: 'security_threats',
+                        config: { chartType: 'timeline', groupBy: 'type' },
+                        order: 2
+                    },
+                    {
+                        id: 'recommendations',
+                        title: 'Security Recommendations',
+                        type: 'text',
+                        dataSource: 'security_analysis',
+                        config: { includeActions: true },
+                        order: 3
+                    }
+                ],
+                formatting: {
+                    pageSize: 'A4',
+                    orientation: 'portrait',
+                    margins: { top: 25, right: 25, bottom: 25, left: 25 },
+                    fontSize: 11,
+                    fontFamily: 'Times New Roman',
+                    includeHeader: true,
+                    includeFooter: true,
+                    headerText: 'Security Analysis Report - {{dateRange}}',
+                    footerText: 'Confidential | Page {{page}} of {{totalPages}}'
+                }
+            }
+        ];
+        defaultTemplates.forEach(template => {
+            this.reportTemplates.set(template.id, template);
+        });
+    }
+    /**
+     * Initialize default export configurations
+     */
+    initializeDefaultConfigs() {
+        const defaultConfigs = [
+            {
+                id: 'daily_metrics_csv',
+                name: 'Daily Metrics Export (CSV)',
+                format: 'csv',
+                dataSource: 'metrics',
+                filters: [
+                    {
+                        field: 'timestamp',
+                        operator: 'greater_than',
+                        value: Date.now() - 86400000 // Last 24 hours
+                    }
+                ],
+                columns: [
+                    { field: 'timestamp', header: 'Timestamp', type: 'date', format: 'ISO' },
+                    { field: 'metric_type', header: 'Metric Type', type: 'string' },
+                    { field: 'value', header: 'Value', type: 'number' },
+                    { field: 'unit', header: 'Unit', type: 'string' }
+                ],
+                schedule: {
+                    enabled: true,
+                    frequency: 'daily',
+                    interval: 1,
+                    time: '06:00',
+                    timezone: 'UTC'
+                },
+                compression: true,
+                encryption: false,
+                destination: {
+                    type: 'local',
+                    config: { path: './exports/daily-metrics' }
+                }
+            },
+            {
+                id: 'security_report_pdf',
+                name: 'Weekly Security Report (PDF)',
+                format: 'pdf',
+                dataSource: 'security',
+                filters: [
+                    {
+                        field: 'timestamp',
+                        operator: 'between',
+                        value: null,
+                        values: [Date.now() - 604800000, Date.now()] // Last 7 days
+                    }
+                ],
+                columns: [
+                    { field: 'id', header: 'Threat ID', type: 'string' },
+                    { field: 'type', header: 'Threat Type', type: 'string' },
+                    { field: 'severity', header: 'Severity', type: 'string' },
+                    { field: 'timestamp', header: 'Detected', type: 'date', format: 'readable' },
+                    { field: 'status', header: 'Status', type: 'string' }
+                ],
+                template: 'security_analysis',
+                schedule: {
+                    enabled: true,
+                    frequency: 'weekly',
+                    interval: 1,
+                    dayOfWeek: 1, // Monday
+                    time: '08:00',
+                    timezone: 'UTC'
+                },
+                compression: false,
+                encryption: true,
+                destination: {
+                    type: 'email',
+                    config: {
+                        to: ['security@example.com'],
+                        subject: 'Weekly Security Report - {{dateRange}}',
+                        body: 'Please find attached the weekly security report for the Index Server.'
+                    }
+                }
+            }
+        ];
+        defaultConfigs.forEach(config => {
+            this.exportConfigs.set(config.id, config);
+            this.scheduleExport(config);
+        });
+    }
+    /**
+     * Start the export scheduler
+     */
+    startScheduler() {
+        // Check for scheduled exports every minute
+        setInterval(() => {
+            this.checkScheduledExports();
+        }, 60000);
+    }
+    /**
+     * Check for scheduled exports that need to run
+     */
+    checkScheduledExports() {
+        const now = Date.now();
+        this.exportConfigs.forEach(config => {
+            if (!config.schedule?.enabled)
+                return;
+            const nextRun = config.schedule.nextRun;
+            if (nextRun && now >= nextRun) {
+                this.executeExport(config.id);
+                this.scheduleExport(config);
+            }
+        });
+    }
+    /**
+     * Schedule an export based on its configuration
+     */
+    scheduleExport(config) {
+        if (!config.schedule?.enabled)
+            return;
+        const schedule = config.schedule;
+        const now = Date.now();
+        let nextRun;
+        switch (schedule.frequency) {
+            case 'hourly':
+                nextRun = now + (schedule.interval * 3600000);
+                break;
+            case 'daily':
+                nextRun = this.getNextDailyRun(schedule);
+                break;
+            case 'weekly':
+                nextRun = this.getNextWeeklyRun(schedule);
+                break;
+            case 'monthly':
+                nextRun = this.getNextMonthlyRun(schedule);
+                break;
+            case 'custom':
+                nextRun = now + (schedule.interval * 1000);
+                break;
+            default:
+                return;
+        }
+        schedule.nextRun = nextRun;
+        schedule.lastRun = now;
+    }
+    /**
+     * Calculate next daily run time
+     */
+    getNextDailyRun(schedule) {
+        const now = new Date();
+        const [hours, minutes] = (schedule.time || '00:00').split(':').map(Number);
+        const nextRun = new Date(now);
+        nextRun.setHours(hours, minutes, 0, 0);
+        // If time has passed today, schedule for tomorrow
+        if (nextRun.getTime() <= now.getTime()) {
+            nextRun.setDate(nextRun.getDate() + schedule.interval);
+        }
+        return nextRun.getTime();
+    }
+    /**
+     * Calculate next weekly run time
+     */
+    getNextWeeklyRun(schedule) {
+        const now = new Date();
+        const [hours, minutes] = (schedule.time || '00:00').split(':').map(Number);
+        const targetDay = schedule.dayOfWeek || 0;
+        const nextRun = new Date(now);
+        nextRun.setHours(hours, minutes, 0, 0);
+        const currentDay = now.getDay();
+        const daysUntilTarget = (targetDay - currentDay + 7) % 7;
+        if (daysUntilTarget === 0 && nextRun.getTime() <= now.getTime()) {
+            // Target day is today but time has passed, schedule for next week
+            nextRun.setDate(nextRun.getDate() + 7);
+        }
+        else if (daysUntilTarget > 0) {
+            nextRun.setDate(nextRun.getDate() + daysUntilTarget);
+        }
+        return nextRun.getTime();
+    }
+    /**
+     * Calculate next monthly run time
+     */
+    getNextMonthlyRun(schedule) {
+        const now = new Date();
+        const [hours, minutes] = (schedule.time || '00:00').split(':').map(Number);
+        const targetDay = schedule.dayOfMonth || 1;
+        const nextRun = new Date(now);
+        nextRun.setDate(targetDay);
+        nextRun.setHours(hours, minutes, 0, 0);
+        // If target day has passed this month, schedule for next month
+        if (nextRun.getTime() <= now.getTime()) {
+            nextRun.setMonth(nextRun.getMonth() + schedule.interval);
+        }
+        return nextRun.getTime();
+    }
+    /**
+     * Execute an export job
+     */
+    async executeExport(configId) {
+        const config = this.exportConfigs.get(configId);
+        if (!config) {
+            throw new Error(`Export configuration not found: ${configId}`);
+        }
+        const jobId = `export_${configId}_${Date.now()}`;
+        const job = {
+            id: jobId,
+            configId,
+            status: 'pending',
+            progress: 0,
+            recordsProcessed: 0,
+            totalRecords: 0,
+            startTime: Date.now()
+        };
+        this.exportJobs.set(jobId, job);
+        this.notifyJobUpdate(job);
+        try {
+            job.status = 'running';
+            this.notifyJobUpdate(job);
+            // Get data based on configuration
+            const data = await this.getData(config);
+            job.totalRecords = Array.isArray(data) ? data.length : 1;
+            // Filter data
+            const filteredData = this.applyFilters(data, config.filters);
+            // Transform data according to columns configuration
+            const transformedData = this.transformData(filteredData, config.columns);
+            // Export data in specified format
+            const outputPath = await this.exportData(transformedData, config);
+            job.status = 'completed';
+            job.progress = 100;
+            job.endTime = Date.now();
+            job.outputPath = outputPath;
+            job.fileSize = await this.getFileSize(outputPath);
+        }
+        catch (error) {
+            job.status = 'failed';
+            job.error = error instanceof Error ? error.message : 'Unknown error';
+            job.endTime = Date.now();
+        }
+        this.notifyJobUpdate(job);
+        return jobId;
+    }
+    /**
+     * Get data from specified source
+     */
+    async getData(config) {
+        switch (config.dataSource) {
+            case 'metrics':
+                return this.getMetricsData();
+            case 'analytics':
+                return this.getAnalyticsData();
+            case 'security':
+                return this.getSecurityData();
+            case 'feedback':
+                return this.getFeedbackData();
+            case 'instructions':
+                return this.getInstructionsData();
+            case 'custom':
+                return this.getCustomData(config);
+            default:
+                throw new Error(`Unsupported data source: ${config.dataSource}`);
+        }
+    }
+    /**
+     * Apply filters to data
+     */
+    applyFilters(data, filters) {
+        if (!filters.length)
+            return data;
+        return data.filter(item => {
+            return filters.every(filter => this.evaluateFilter(item, filter));
+        });
+    }
+    /**
+     * Evaluate a single filter against a data item
+     */
+    evaluateFilter(item, filter) {
+        if (!item || typeof item !== 'object')
+            return false;
+        const value = item[filter.field];
+        switch (filter.operator) {
+            case 'equals':
+                return value === filter.value;
+            case 'not_equals':
+                return value !== filter.value;
+            case 'contains':
+                return String(value).includes(String(filter.value));
+            case 'not_contains':
+                return !String(value).includes(String(filter.value));
+            case 'greater_than':
+                return Number(value) > Number(filter.value);
+            case 'less_than':
+                return Number(value) < Number(filter.value);
+            case 'between': {
+                if (!filter.values || filter.values.length !== 2)
+                    return false;
+                const numValue = Number(value);
+                return numValue >= Number(filter.values[0]) && numValue <= Number(filter.values[1]);
+            }
+            case 'in':
+                return filter.values ? filter.values.includes(value) : false;
+            case 'not_in':
+                return filter.values ? !filter.values.includes(value) : true;
+            default:
+                return true;
+        }
+    }
+    /**
+     * Transform data according to column configuration
+     */
+    transformData(data, columns) {
+        if (!columns.length)
+            return data;
+        return data.map(item => {
+            if (!item || typeof item !== 'object')
+                return item;
+            const transformedItem = {};
+            const itemRecord = item;
+            columns.forEach(column => {
+                let value = itemRecord[column.field];
+                // Apply type conversion and formatting
+                switch (column.type) {
+                    case 'date':
+                        if (typeof value === 'number') {
+                            const date = new Date(value);
+                            value = column.format === 'ISO' ? date.toISOString() : date.toLocaleString();
+                        }
+                        break;
+                    case 'number':
+                        value = Number(value);
+                        break;
+                    case 'boolean':
+                        value = Boolean(value);
+                        break;
+                    case 'json':
+                        value = typeof value === 'object' ? JSON.stringify(value) : value;
+                        break;
+                    case 'string':
+                    default:
+                        value = String(value);
+                        break;
+                }
+                transformedItem[column.header] = value;
+            });
+            return transformedItem;
+        });
+    }
+    /**
+     * Export data in specified format
+     */
+    async exportData(data, config) {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        const fileName = `${config.name}_${timestamp}.${config.format}`;
+        const outputPath = this.getOutputPath(config, fileName);
+        switch (config.format) {
+            case 'json':
+                await this.exportJSON(data, outputPath, config);
+                break;
+            case 'csv':
+                await this.exportCSV(data, outputPath, config);
+                break;
+            case 'excel':
+                await this.exportExcel(data, outputPath, config);
+                break;
+            case 'pdf':
+                await this.exportPDF(data, outputPath, config);
+                break;
+            case 'xml':
+                await this.exportXML(data, outputPath, config);
+                break;
+            default:
+                throw new Error(`Unsupported export format: ${config.format}`);
+        }
+        return outputPath;
+    }
+    /**
+     * Get output path for export
+     */
+    getOutputPath(config, fileName) {
+        const destination = config.destination;
+        if (destination.type === 'local') {
+            const basePath = destination.config.path || './exports';
+            return `${basePath}/${fileName}`;
+        }
+        // For other destination types, use temporary local path
+        return `./tmp/exports/${fileName}`;
+    }
+    /**
+     * Export data as JSON
+     */
+    async exportJSON(data, outputPath, config) {
+        await (0, jsonExporter_js_1.exportJSON)(data, outputPath, config.compression);
+    }
+    /**
+     * Export data as CSV
+     */
+    async exportCSV(data, outputPath, config) {
+        await (0, csvExporter_js_1.exportCSV)(data, outputPath, config.compression);
+    }
+    /**
+     * Export data as Excel (simplified implementation)
+     */
+    async exportExcel(data, outputPath, _config) {
+        await (0, csvExporter_js_1.exportExcel)(data, outputPath, _config.compression);
+    }
+    /**
+     * Export data as PDF using template
+     */
+    async exportPDF(data, outputPath, config) {
+        const template = config.template ? this.reportTemplates.get(config.template) : undefined;
+        await (0, xmlExporter_js_1.exportPDF)(data, outputPath, template);
+    }
+    /**
+     * Export data as XML
+     */
+    async exportXML(data, outputPath, config) {
+        await (0, xmlExporter_js_1.exportXML)(data, outputPath, config.compression);
+    }
+    /**
+     * Get file size
+     */
+    async getFileSize(filePath) {
+        try {
+            const fs = await import('fs').then(m => m.promises);
+            const stats = await fs.stat(filePath);
+            return stats.size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * Data source methods (simplified implementations)
+     */
+    getMetricsData() {
+        // Simulated metrics data
+        return Array.from({ length: 100 }, (_, i) => ({
+            id: `metric_${i}`,
+            timestamp: Date.now() - (i * 60000),
+            metric_type: ['cpu', 'memory', 'disk', 'network'][i % 4],
+            value: Math.random() * 100,
+            unit: ['percentage', 'MB', 'GB', 'Mbps'][i % 4]
+        }));
+    }
+    getAnalyticsData() {
+        // Simulated analytics data
+        return Array.from({ length: 50 }, (_, i) => ({
+            id: `analytics_${i}`,
+            timestamp: Date.now() - (i * 3600000),
+            event_type: ['page_view', 'api_call', 'error', 'warning'][i % 4],
+            count: Math.floor(Math.random() * 1000),
+            source: ['dashboard', 'api', 'webhook', 'scheduler'][i % 4]
+        }));
+    }
+    getSecurityData() {
+        // Simulated security data
+        return Array.from({ length: 20 }, (_, i) => ({
+            id: `threat_${i}`,
+            timestamp: Date.now() - (i * 7200000),
+            type: ['rate_limit_exceeded', 'suspicious_activity', 'authentication_failure'][i % 3],
+            severity: ['low', 'medium', 'high', 'critical'][i % 4],
+            source: `192.168.1.${100 + i}`,
+            status: ['active', 'mitigated', 'resolved'][i % 3]
+        }));
+    }
+    getFeedbackData() {
+        // Simulated feedback data
+        return Array.from({ length: 30 }, (_, i) => ({
+            id: `feedback_${i}`,
+            timestamp: Date.now() - (i * 86400000),
+            type: ['bug-report', 'feature-request', 'issue'][i % 3],
+            severity: ['low', 'medium', 'high'][i % 3],
+            title: `Sample feedback item ${i}`,
+            status: ['new', 'acknowledged', 'in-progress', 'resolved'][i % 4]
+        }));
+    }
+    getInstructionsData() {
+        // Simulated instructions data
+        return Array.from({ length: 40 }, (_, i) => ({
+            id: `instruction_${i}`,
+            timestamp: Date.now() - (i * 3600000),
+            type: 'instruction',
+            title: `Sample instruction ${i}`,
+            author: `user_${i % 5}`,
+            status: ['active', 'draft', 'archived'][i % 3]
+        }));
+    }
+    getCustomData(_config) {
+        // Placeholder for custom data sources
+        return [];
+    }
+    /**
+     * Notify job update
+     */
+    notifyJobUpdate(job) {
+        this.jobCallbacks.forEach(callback => {
+            try {
+                callback(job);
+            }
+            catch (error) {
+                console.error('Error in export job callback:', error);
+            }
+        });
+    }
+    // Public API methods
+    /**
+     * Create export configuration
+     */
+    createExportConfig(config) {
+        const id = `export_${Date.now()}`;
+        const fullConfig = { id, ...config };
+        this.exportConfigs.set(id, fullConfig);
+        if (fullConfig.schedule?.enabled) {
+            this.scheduleExport(fullConfig);
+        }
+        return id;
+    }
+    /**
+     * Get export configuration
+     */
+    getExportConfig(id) {
+        return this.exportConfigs.get(id);
+    }
+    /**
+     * List all export configurations
+     */
+    listExportConfigs() {
+        return Array.from(this.exportConfigs.values());
+    }
+    /**
+     * Update export configuration
+     */
+    updateExportConfig(id, updates) {
+        const config = this.exportConfigs.get(id);
+        if (!config)
+            return false;
+        Object.assign(config, updates);
+        if (config.schedule?.enabled) {
+            this.scheduleExport(config);
+        }
+        return true;
+    }
+    /**
+     * Delete export configuration
+     */
+    deleteExportConfig(id) {
+        const deleted = this.exportConfigs.delete(id);
+        // Cancel scheduled job if exists
+        const scheduledJob = this.scheduledJobs.get(id);
+        if (scheduledJob) {
+            clearTimeout(scheduledJob);
+            this.scheduledJobs.delete(id);
+        }
+        return deleted;
+    }
+    /**
+     * Get export job
+     */
+    getExportJob(id) {
+        return this.exportJobs.get(id);
+    }
+    /**
+     * List export jobs
+     */
+    listExportJobs(configId) {
+        const jobs = Array.from(this.exportJobs.values());
+        return configId ? jobs.filter(job => job.configId === configId) : jobs;
+    }
+    /**
+     * Cancel export job
+     */
+    cancelExportJob(id) {
+        const job = this.exportJobs.get(id);
+        if (!job || job.status !== 'running')
+            return false;
+        job.status = 'cancelled';
+        job.endTime = Date.now();
+        this.notifyJobUpdate(job);
+        return true;
+    }
+    /**
+     * Register job update callback
+     */
+    onJobUpdate(callback) {
+        this.jobCallbacks.push(callback);
+    }
+    /**
+     * Create report template
+     */
+    createReportTemplate(template) {
+        const id = `template_${Date.now()}`;
+        const fullTemplate = { id, ...template };
+        this.reportTemplates.set(id, fullTemplate);
+        return id;
+    }
+    /**
+     * Get report template
+     */
+    getReportTemplate(id) {
+        return this.reportTemplates.get(id);
+    }
+    /**
+     * List report templates
+     */
+    listReportTemplates() {
+        return Array.from(this.reportTemplates.values());
+    }
+    /**
+     * Get active export jobs
+     */
+    getActiveJobs() {
+        const activeJobs = [];
+        const jobValues = Array.from(this.exportJobs.values());
+        for (const job of jobValues) {
+            if (job.status === 'pending' || job.status === 'running') {
+                activeJobs.push(job);
+            }
+        }
+        return activeJobs;
+    }
+}
+exports.DataExporter = DataExporter;