- {Object.entries(analyticsData.nginx.summary.topReferers)
- .sort(([, a], [, b]) => b - a)
- .slice(0, 10)
- .map(([referer, count]) => (
-
-
{referer || 'Direct'}
-
-
-
{count}
+ {(() => {
+ const topReferers = analyticsData.nginx.summary.topReferers;
+ console.log('EnhancedAnalyticsDashboard topReferers:', topReferers); // Debug log
+
+ if (!topReferers || typeof topReferers !== 'object') {
+ console.warn('EnhancedAnalyticsDashboard topReferers is not an object:', topReferers);
+ return
No referer data available
;
+ }
+
+ return Object.entries(topReferers)
+ .sort(([, a], [, b]) => b - a)
+ .slice(0, 10)
+ .map(([referer, count]) => (
+
+
{referer || 'Direct'}
+
-
- ))}
+ ));
+ })()}
diff --git a/src/components/analytics/FingerprintAnalyticsDashboard.tsx b/src/components/analytics/FingerprintAnalyticsDashboard.tsx
new file mode 100644
index 0000000..0afa252
--- /dev/null
+++ b/src/components/analytics/FingerprintAnalyticsDashboard.tsx
@@ -0,0 +1,714 @@
+'use client';
+
+import React, { useState, useEffect } from 'react';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { Button } from '@/components/ui/button';
+import { Tabs, TabsContent, TabsList, TabsTrigger } from '@/components/ui/tabs';
+import {
+ Users,
+ Monitor,
+ Smartphone,
+ Globe,
+ Clock,
+ MousePointer,
+ Scroll,
+ Type,
+ Activity,
+ Fingerprint,
+ MapPin
+} from 'lucide-react';
+
+interface FingerprintEntry {
+ timestamp: string;
+ visitorId: string;
+ ipAddress: string;
+ userAgent: string;
+ browser: string;
+ deviceType: string;
+ screenResolution: string;
+ timezone: string;
+ language: string;
+ platform: string;
+ cpuCores: number;
+ memorySize: number;
+ canvas: string;
+ webgl: string;
+ audio: string;
+ fonts: string;
+ plugins: string;
+ sessionId: string;
+ pageUrl: string;
+ referrer: string;
+ timeOnPage: number;
+ scrollDepth: number;
+ clicks: number;
+ scrolls: number;
+ formInteractions: number;
+}
+
+interface FingerprintAnalytics {
+ totalVisitors: number;
+ uniqueVisitors: number;
+ totalSessions: number;
+ averageTimeOnSite: number;
+ averageScrollDepth: number;
+ browsers: Record
;
+ devices: Record;
+ timezones: Record;
+ languages: Record;
+ platforms: Record;
+ screenResolutions: Record;
+ topPages: Record;
+ topReferrers: Record;
+ interactionStats: {
+ averageClicks: number;
+ averageScrolls: number;
+ averageFormInteractions: number;
+ };
+ recentVisitors: FingerprintEntry[];
+}
+
+export default function FingerprintAnalyticsDashboard() {
+ const [analytics, setAnalytics] = useState(null);
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState(null);
+
+ useEffect(() => {
+ fetchFingerprintAnalytics();
+ }, []);
+
+ const fetchFingerprintAnalytics = async () => {
+ try {
+ setLoading(true);
+ const response = await fetch('/api/analytics/fingerprint');
+ if (!response.ok) throw new Error('Failed to fetch fingerprint analytics');
+ const data = await response.json();
+ setAnalytics(data);
+ } catch (err) {
+ console.error('Error fetching fingerprint analytics:', err);
+ setError(err instanceof Error ? err.message : 'An error occurred');
+ } finally {
+ setLoading(false);
+ }
+ };
+
+ if (loading) {
+ return (
+
+ );
+ }
+
+ if (error) {
+ return (
+
+
+
+ {error}
+
+
+
+ );
+ }
+
+ if (!analytics) {
+ return (
+
+
+
+ No fingerprint analytics data available
+
+
+
+ );
+ }
+
+ return (
+
+
+
+
Fingerprint Analytics
+
Advanced visitor tracking and behavioral analytics
+
+
+
+
+ {/* Overview Cards */}
+
+
+
+ Total Visitors
+
+
+
+ {analytics.totalVisitors}
+
+ {analytics.uniqueVisitors} unique visitors
+
+
+
+
+
+
+ Total Sessions
+
+
+
+ {analytics.totalSessions}
+
+ Average {Math.round(analytics.averageTimeOnSite / 1000)}s per session
+
+
+
+
+
+
+ Avg. Time on Site
+
+
+
+ {Math.round(analytics.averageTimeOnSite / 1000)}s
+
+ {Math.round(analytics.averageScrollDepth)}% scroll depth
+
+
+
+
+
+
+ Interactions
+
+
+
+ {Math.round(analytics.interactionStats.averageClicks)}
+
+ {Math.round(analytics.interactionStats.averageScrolls)} scrolls, {Math.round(analytics.interactionStats.averageFormInteractions)} forms
+
+
+
+
+
+ {/* Detailed Analytics */}
+
+
+ Browsers
+ Devices
+ Locations
+ IP Addresses
+ Hardware
+ Browser Fingerprint
+ Session Analytics
+ Pages
+ Recent Visitors
+
+
+
+
+
+
+
+ Browser Distribution
+
+
+
+
+ {Object.entries(analytics.browsers)
+ .sort(([, a], [, b]) => b - a)
+ .map(([browser, count]) => (
+
+ {browser}
+ {count}
+
+ ))}
+
+ {Object.entries(analytics.devices)
+ .sort(([, a], [, b]) => b - a)
+ .map(([device, count]) => (
+
+ {device}
+ {count}
+
+ ))}
+
+
+
+
+
+ Timezones
+
+
+
+
+ {Object.entries(analytics.timezones)
+ .sort(([, a], [, b]) => b - a)
+ .slice(0, 10)
+ .map(([timezone, count]) => (
+
+ {timezone}
+ {count}
+
+ ))}
+
+
+
+
+
+
+ Languages
+
+
+
+
+ {Object.entries(analytics.languages)
+ .sort(([, a], [, b]) => b - a)
+ .slice(0, 10)
+ .map(([language, count]) => (
+
+ {language}
+ {count}
+
+ ))}
+
+
+ {analytics.recentVisitors
+ .filter((visitor, index, self) =>
+ self.findIndex(v => v.ipAddress === visitor.ipAddress) === index
+ )
+ .slice(0, 20)
+ .map((visitor, index) => (
+
+
+ {visitor.ipAddress}
+ {visitor.browser}
+ {visitor.deviceType}
+
+
+ {new Date(visitor.timestamp).toLocaleString()}
+
+
+ ))}
+
+
+
+
+
+ CPU Cores
+
+
+
+
+ {analytics.recentVisitors
+ .filter((visitor, index, self) =>
+ self.findIndex(v => v.cpuCores === visitor.cpuCores) === index
+ )
+ .slice(0, 10)
+ .map((visitor, index) => (
+
+ {visitor.cpuCores} cores
+ {visitor.platform}
+
+ ))}
+
+
+
+
+
+
+ Memory Size
+
+
+
+
+ {analytics.recentVisitors
+ .filter((visitor, index, self) =>
+ self.findIndex(v => v.memorySize === visitor.memorySize) === index
+ )
+ .slice(0, 10)
+ .map((visitor, index) => (
+
+ {(visitor.memorySize / 1024 / 1024).toFixed(1)} GB
+ {visitor.platform}
+
+ ))}
+
+
+
+
+
+
+ Screen Resolutions
+
+
+
+
+ {analytics.recentVisitors
+ .filter((visitor, index, self) =>
+ self.findIndex(v => v.screenResolution === visitor.screenResolution) === index
+ )
+ .slice(0, 10)
+ .map((visitor, index) => (
+
+ {visitor.screenResolution}
+ {visitor.deviceType}
+
+ ))}
+
+
+
+
+
+
+ Fonts Available
+
+
+
+
+ {analytics.recentVisitors
+ .filter((visitor, index, self) =>
+ self.findIndex(v => v.fonts === visitor.fonts) === index
+ )
+ .slice(0, 5)
+ .map((visitor, index) => (
+
+
Fonts: {visitor.fonts.split(',').length} available
+
{visitor.fonts}
+
+ ))}
+
+
+
+
+
+
+ Plugins
+
+
+
+
+ {analytics.recentVisitors
+ .filter((visitor, index, self) =>
+ self.findIndex(v => v.plugins === visitor.plugins) === index
+ )
+ .slice(0, 5)
+ .map((visitor, index) => (
+
+
Plugins: {visitor.plugins.split(',').length} available
+
{visitor.plugins}
+
+ ))}
+
+
+
+
+
+
+ WebGL Info
+
+
+
+
+ {analytics.recentVisitors
+ .filter((visitor, index, self) =>
+ self.findIndex(v => v.webgl === visitor.webgl) === index
+ )
+ .slice(0, 5)
+ .map((visitor, index) => (
+
+
WebGL: {visitor.webgl}
+
Audio: {visitor.audio} Hz
+
+ ))}
+
+
+
+
+
+
+ Canvas Fingerprint
+
+
+
+
+ {analytics.recentVisitors
+ .slice(0, 3)
+ .map((visitor, index) => (
+
+
Canvas Hash
+
+ {visitor.canvas.substring(0, 50)}...
+
+
+ ))}
+
+
+
+
+
+
+ Time on Page
+
+
+
+
+ {analytics.recentVisitors
+ .slice(0, 10)
+ .map((visitor, index) => (
+
+ {(visitor.timeOnPage / 1000).toFixed(1)}s
+ {visitor.pageUrl.split('/').pop()}
+
+ ))}
+
+
+
+
+
+
+ Click Activity
+
+
+
+
+ {analytics.recentVisitors
+ .slice(0, 10)
+ .map((visitor, index) => (
+
+ {visitor.clicks} clicks
+ {visitor.pageUrl.split('/').pop()}
+
+ ))}
+
+
+
+
+
+
+ Scroll Activity
+
+
+
+
+ {analytics.recentVisitors
+ .slice(0, 10)
+ .map((visitor, index) => (
+
+ {visitor.scrolls} scrolls
+ {visitor.pageUrl.split('/').pop()}
+
+ ))}
+
+
+
+
+
+
+ Scroll Depth
+
+
+
+
+ {analytics.recentVisitors
+ .slice(0, 10)
+ .map((visitor, index) => (
+
+ {visitor.scrollDepth}%
+ {visitor.pageUrl.split('/').pop()}
+
+ ))}
+
+
+
+
+
+
+ Form Interactions
+
+
+
+
+ {analytics.recentVisitors
+ .slice(0, 10)
+ .map((visitor, index) => (
+
+ {visitor.formInteractions} interactions
+ {visitor.pageUrl.split('/').pop()}
+
+ ))}
+
+
+
+
+
+
+ Session IDs
+
+
+
+
+ {analytics.recentVisitors
+ .filter((visitor, index, self) =>
+ self.findIndex(v => v.sessionId === visitor.sessionId) === index
+ )
+ .slice(0, 10)
+ .map((visitor, index) => (
+
+
Session
+
{visitor.sessionId}
+
+ ))}
+
+
+ {Object.entries(analytics.topPages)
+ .sort(([, a], [, b]) => b - a)
+ .slice(0, 15)
+ .map(([page, count]) => (
+
+ {page}
+ {count}
+
+ ))}
+
+ {analytics.recentVisitors.slice(0, 10).map((visitor, index) => (
+
+
+
+ {visitor.deviceType}
+ {visitor.browser}
+ {visitor.ipAddress}
+
+
+ {new Date(visitor.timestamp).toLocaleString()}
+
+
+
+
Page: {visitor.pageUrl}
+
Session: {visitor.sessionId}
+
Time on Page: {Math.round(visitor.timeOnPage / 1000)}s
+
Interactions: {visitor.clicks} clicks, {visitor.scrolls} scrolls
+
+
+ ))}
+
+
- {Object.entries(analytics.devices).map(([device, count]) => (
-
- {device}
- {count}
-
- ))}
- {Object.entries(analytics.browsers).map(([browser, count]) => (
-
- {browser}
- {count}
-
- ))}
+ {(() => {
+ const devices = analytics.devices;
+ const browsers = analytics.browsers;
+
+ console.log('IPDetailsModal Devices:', devices); // Debug log
+ console.log('IPDetailsModal Browsers:', browsers); // Debug log
+
+ return (
+ <>
+ {devices && typeof devices === 'object' && Object.entries(devices).map(([device, count]) => (
+
+ {device}
+ {count}
+
+ ))}
+ {browsers && typeof browsers === 'object' && Object.entries(browsers).map(([browser, count]) => (
+
+ {browser}
+ {count}
+
+ ))}
+
+ );
+ })()}
- {Object.entries(analytics.pages)
- .sort(([, a], [, b]) => b - a)
- .map(([page, count]) => (
-
-
{page}
-
-
-
{count}
+ {(() => {
+ const pages = analytics.pages;
+ console.log('IPDetailsModal Pages:', pages); // Debug log
+
+ if (!pages || typeof pages !== 'object') {
+ console.warn('IPDetailsModal pages is not an object:', pages);
+ return
No page data available
;
+ }
+
+ return Object.entries(pages)
+ .sort(([, a], [, b]) => b - a)
+ .map(([page, count]) => (
+
-
- ))}
+ ));
+ })()}
@@ -291,29 +313,39 @@ export default function IPDetailsModal({ isOpen, onClose, ipAddress, dateRange }
- {analytics.sessionDetails.map((session, index) => (
-
-
-
-
Session {index + 1}
-
- {formatDate(session.startTime)} - {formatDate(session.endTime)}
-
+ {(() => {
+ const sessionDetails = analytics.sessionDetails;
+ console.log('IPDetailsModal Session Details:', sessionDetails); // Debug log
+
+ if (!sessionDetails || !Array.isArray(sessionDetails)) {
+ console.warn('IPDetailsModal sessionDetails is not an array:', sessionDetails);
+ return
No session details available
;
+ }
+
+ return sessionDetails.map((session, index) => (
+
+
+
+
Session {index + 1}
+
+ {formatDate(session.startTime)} - {formatDate(session.endTime)}
+
+
+
{formatDuration(session.duration)}
+
+
+ {session.totalRequests} requests
+
+
+ {(session.pages || []).map((page, pageIndex) => (
+
+ {page}
+
+ ))}
-
{formatDuration(session.duration)}
-
-
- {session.totalRequests} requests
-
-
- {session.pages.map((page, pageIndex) => (
-
- {page}
-
- ))}
-
- ))}
+ ));
+ })()}
@@ -326,18 +358,27 @@ export default function IPDetailsModal({ isOpen, onClose, ipAddress, dateRange }
- {logs.map((log, index) => (
-
-
-
{formatDate(log.timestamp)}
-
= 400 ? 'destructive' : 'default'}>
- {log.statusCode}
-
+ {(() => {
+ console.log('IPDetailsModal Logs data:', logs); // Debug log
+
+ if (!logs || !Array.isArray(logs)) {
+ console.warn('IPDetailsModal logs is not an array:', logs);
+ return
No logs available
;
+ }
+
+ return logs.map((log, index) => (
+
+
+ {formatDate(log.timestamp)}
+ = 400 ? 'destructive' : 'default'}>
+ {log.statusCode}
+
+
+
{log.method} {log.path}
+
{log.userAgent}
-
{log.method} {log.path}
-
{log.userAgent}
-
- ))}
+ ));
+ })()}
diff --git a/src/components/analytics/MarketingIntelligenceDashboard.tsx b/src/components/analytics/MarketingIntelligenceDashboard.tsx
old mode 100644
new mode 100755
index 44e4406..333f9c0
--- a/src/components/analytics/MarketingIntelligenceDashboard.tsx
+++ b/src/components/analytics/MarketingIntelligenceDashboard.tsx
@@ -304,50 +304,59 @@ export default function MarketingIntelligenceDashboard() {
- {visitorProfiles.map((visitor) => (
-
setSelectedVisitor(visitor)}
- >
-
-
-
-
-
{visitor.ip}
-
- {visitor.totalVisits} visits âĸ {formatDuration(visitor.totalTimeOnSite)}
-
-
-
-
-
- {Math.round(visitor.leadScore * 100)}%
-
-
Lead Score
-
-
+ {(() => {
+ console.log('MarketingIntelligenceDashboard visitorProfiles:', visitorProfiles); // Debug log
-
-
-
- {visitor.timeBasedPatterns.returnVisitor ? "Return Visitor" : "New Visitor"}
-
-
- {visitor.highEngagementPages.length} key pages
-
-
- {visitor.conversionEvents.length} conversions
-
-
-
-
-
- Last visit: {new Date(visitor.lastVisit).toLocaleString()}
-
-
-
- ))}
+ if (!visitorProfiles || !Array.isArray(visitorProfiles)) {
+ console.warn('MarketingIntelligenceDashboard visitorProfiles is not an array:', visitorProfiles);
+ return
No visitor profiles available
;
+ }
+
+ return visitorProfiles.map((visitor) => (
+
setSelectedVisitor(visitor)}
+ >
+
+
+
+
+
{visitor.ip}
+
+ {visitor.totalVisits} visits âĸ {formatDuration(visitor.totalTimeOnSite)}
+
+
+
+
+
+ {Math.round(visitor.leadScore * 100)}%
+
+
Lead Score
+
+
+
+
+
+
+ {visitor.timeBasedPatterns.returnVisitor ? "Return Visitor" : "New Visitor"}
+
+
+ {visitor.highEngagementPages.length} key pages
+
+
+ {visitor.conversionEvents.length} conversions
+
+
+
+
+
+ Last visit: {new Date(visitor.lastVisit).toLocaleString()}
+
+
+
+ ));
+ })()}
@@ -366,22 +375,32 @@ export default function MarketingIntelligenceDashboard() {
- {salesIntelligence.highValueVisitors.map((visitor) => (
-
-
-
{visitor.ip}
-
- {visitor.conversionEvents.join(', ')}
+ {(() => {
+ const highValueVisitors = salesIntelligence?.highValueVisitors;
+ console.log('MarketingIntelligenceDashboard highValueVisitors:', highValueVisitors); // Debug log
+
+ if (!highValueVisitors || !Array.isArray(highValueVisitors)) {
+ console.warn('MarketingIntelligenceDashboard highValueVisitors is not an array:', highValueVisitors);
+ return
No high value visitors available
;
+ }
+
+ return highValueVisitors.map((visitor) => (
+
+
+
{visitor.ip}
+
+ {visitor.conversionEvents.join(', ')}
+
-
-
-
- {Math.round(visitor.leadScore * 100)}%
+
+
+ {Math.round(visitor.leadScore * 100)}%
+
+
Score
-
Score
-
- ))}
+ ));
+ })()}
@@ -395,7 +414,16 @@ export default function MarketingIntelligenceDashboard() {
- {salesIntelligence.conversionOpportunities.map((opp) => (
+ {(() => {
+ const conversionOpportunities = salesIntelligence?.conversionOpportunities;
+ console.log('MarketingIntelligenceDashboard conversionOpportunities:', conversionOpportunities); // Debug log
+
+ if (!conversionOpportunities || !Array.isArray(conversionOpportunities)) {
+ console.warn('MarketingIntelligenceDashboard conversionOpportunities is not an array:', conversionOpportunities);
+ return
No conversion opportunities available
;
+ }
+
+ return conversionOpportunities.map((opp) => (
{opp.visitor.ip}
@@ -407,7 +435,8 @@ export default function MarketingIntelligenceDashboard() {
{opp.opportunity}
- ))}
+ ));
+ })()}
diff --git a/src/components/analytics/UniqueIPsList.tsx b/src/components/analytics/UniqueIPsList.tsx
old mode 100644
new mode 100755
diff --git a/src/components/shared/UpdateBanner.tsx b/src/components/shared/UpdateBanner.tsx
old mode 100644
new mode 100755
diff --git a/src/components/ui/dialog.tsx b/src/components/ui/dialog.tsx
old mode 100644
new mode 100755
diff --git a/src/components/ui/progress.tsx b/src/components/ui/progress.tsx
old mode 100644
new mode 100755
diff --git a/src/components/ui/select.tsx b/src/components/ui/select.tsx
old mode 100644
new mode 100755
diff --git a/src/components/ui/tabs.tsx b/src/components/ui/tabs.tsx
old mode 100644
new mode 100755
diff --git a/src/lib/botDetection.ts b/src/lib/botDetection.ts
old mode 100644
new mode 100755
diff --git a/src/lib/config.ts b/src/lib/config.ts
old mode 100644
new mode 100755
diff --git a/src/lib/exportUtils.ts b/src/lib/exportUtils.ts
old mode 100644
new mode 100755
diff --git a/src/lib/fingerprintTracker.ts b/src/lib/fingerprintTracker.ts
new file mode 100644
index 0000000..c098b44
--- /dev/null
+++ b/src/lib/fingerprintTracker.ts
@@ -0,0 +1,313 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import FingerprintJS from '@fingerprintjs/fingerprintjs';
+
+export interface FingerprintData {
+ timestamp: string;
+ visitorId: string;
+ ipAddress: string;
+ userAgent: string;
+ browser: string;
+ deviceType: string;
+ screenResolution: string;
+ timezone: string;
+ language: string;
+ platform: string;
+ cpuCores: number;
+ memorySize: number;
+ canvas: string;
+ webgl: string;
+ audio: string;
+ fonts: string[];
+ plugins: string[];
+ sessionId: string;
+ pageUrl: string;
+ referrer: string;
+ timeOnPage: number;
+ scrollDepth: number;
+ interactions: {
+ clicks: number;
+ scrolls: number;
+ formInteractions: number;
+ };
+}
+
+class FingerprintTracker {
+ private fpPromise: Promise
| null = null;
+ private sessionId: string;
+ private startTime: number;
+ private interactions = {
+ clicks: 0,
+ scrolls: 0,
+ formInteractions: 0
+ };
+
+ constructor() {
+ this.sessionId = this.generateSessionId();
+ this.startTime = Date.now();
+ this.initializeFingerprint();
+ this.setupEventListeners();
+ }
+
+ private generateSessionId(): string {
+ return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+ }
+
+ private async initializeFingerprint() {
+ try {
+ this.fpPromise = FingerprintJS.load();
+ } catch (error) {
+ console.error('Failed to initialize FingerprintJS:', error);
+ }
+ }
+
+ private setupEventListeners() {
+ // Track clicks
+ document.addEventListener('click', () => {
+ this.interactions.clicks++;
+ });
+
+ // Track scrolls
+ let scrollTimeout: NodeJS.Timeout;
+ document.addEventListener('scroll', () => {
+ this.interactions.scrolls++;
+ clearTimeout(scrollTimeout);
+ scrollTimeout = setTimeout(() => {
+ this.trackScrollDepth();
+ }, 100);
+ });
+
+ // Track form interactions
+ document.addEventListener('input', (e) => {
+ if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement) {
+ this.interactions.formInteractions++;
+ }
+ });
+
+ // Track page visibility changes
+ document.addEventListener('visibilitychange', () => {
+ if (document.visibilityState === 'hidden') {
+ this.sendFingerprintData();
+ }
+ });
+
+ // Track before unload
+ window.addEventListener('beforeunload', () => {
+ this.sendFingerprintData();
+ });
+ }
+
+ private trackScrollDepth() {
+ const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
+ const scrollHeight = document.documentElement.scrollHeight - window.innerHeight;
+ const scrollDepth = Math.round((scrollTop / scrollHeight) * 100);
+
+ // Update scroll depth in session storage
+ sessionStorage.setItem('scrollDepth', scrollDepth.toString());
+ }
+
+ private async getFingerprintData(): Promise> {
+ try {
+ if (!this.fpPromise) {
+ throw new Error('FingerprintJS not initialized');
+ }
+
+ const fp = await this.fpPromise;
+ const result: any = await fp.get();
+
+ return {
+ visitorId: result.visitorId,
+ userAgent: navigator.userAgent,
+ browser: this.getBrowserInfo(),
+ deviceType: this.getDeviceType(),
+ screenResolution: `${screen.width}x${screen.height}`,
+ timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+ language: navigator.language,
+ platform: navigator.platform,
+ cpuCores: navigator.hardwareConcurrency || 0,
+ memorySize: (performance as any).memory?.usedJSHeapSize || 0,
+ canvas: this.getCanvasFingerprint(),
+ webgl: this.getWebGLFingerprint(),
+ audio: this.getAudioFingerprint(),
+ fonts: this.getAvailableFonts(),
+ plugins: Array.from(navigator.plugins).map(p => p.name),
+ sessionId: this.sessionId,
+ pageUrl: window.location.href,
+ referrer: document.referrer,
+ timeOnPage: Date.now() - this.startTime,
+ scrollDepth: parseInt(sessionStorage.getItem('scrollDepth') || '0'),
+ interactions: { ...this.interactions }
+ };
+ } catch (error) {
+ console.error('Error getting fingerprint data:', error);
+ return {};
+ }
+ }
+
+ private getBrowserInfo(): string {
+ const userAgent = navigator.userAgent;
+ if (userAgent.includes('Chrome')) return 'Chrome';
+ if (userAgent.includes('Firefox')) return 'Firefox';
+ if (userAgent.includes('Safari')) return 'Safari';
+ if (userAgent.includes('Edge')) return 'Edge';
+ return 'Unknown';
+ }
+
+ private getDeviceType(): string {
+ const userAgent = navigator.userAgent.toLowerCase();
+ if (/mobile|android|iphone|ipad|phone/i.test(userAgent)) return 'mobile';
+ if (/tablet|ipad/i.test(userAgent)) return 'tablet';
+ return 'desktop';
+ }
+
+ private getCanvasFingerprint(): string {
+ try {
+ const canvas = document.createElement('canvas');
+ const ctx = canvas.getContext('2d');
+ if (!ctx) return '';
+
+ ctx.textBaseline = 'top';
+ ctx.font = '14px Arial';
+ ctx.fillText('FingerprintJS Canvas', 2, 2);
+ return canvas.toDataURL();
+ } catch (error) {
+ return '';
+ }
+ }
+
+ private getWebGLFingerprint(): string {
+ try {
+ const canvas = document.createElement('canvas');
+ const gl = canvas.getContext('webgl') || canvas.getContext('experimental-webgl') as WebGLRenderingContext;
+ if (!gl) return '';
+
+ return gl.getParameter(gl.VENDOR) + '~' + gl.getParameter(gl.RENDERER);
+ } catch (error) {
+ return '';
+ }
+ }
+
+ private getAudioFingerprint(): string {
+ try {
+ const audioContext = new (window.AudioContext || (window as any).webkitAudioContext)();
+ const oscillator = audioContext.createOscillator();
+ const analyser = audioContext.createAnalyser();
+ const gainNode = audioContext.createGain();
+ const scriptProcessor = audioContext.createScriptProcessor(4096, 1, 1);
+
+ gainNode.gain.value = 0;
+ oscillator.type = 'triangle';
+ oscillator.connect(analyser);
+ analyser.connect(scriptProcessor);
+ scriptProcessor.connect(gainNode);
+ gainNode.connect(audioContext.destination);
+
+ oscillator.start(0);
+ gainNode.gain.setValueAtTime(1, audioContext.currentTime);
+ gainNode.gain.exponentialRampToValueAtTime(1, audioContext.currentTime + 0.001);
+
+ return audioContext.sampleRate.toString();
+ } catch (error) {
+ return '';
+ }
+ }
+
+ private getAvailableFonts(): string[] {
+ const baseFonts = ['monospace', 'sans-serif', 'serif'];
+ const fontList = [
+ 'Arial', 'Verdana', 'Helvetica', 'Times New Roman', 'Courier New',
+ 'Georgia', 'Palatino', 'Garamond', 'Bookman', 'Comic Sans MS',
+ 'Trebuchet MS', 'Arial Black', 'Impact', 'Lucida Console'
+ ];
+
+ const availableFonts: string[] = [];
+
+ for (const font of fontList) {
+ let matched = 0;
+ for (const baseFont of baseFonts) {
+ const testString = 'mmmmmmmmmmlli';
+ const testSize = '72px';
+ const canvas = document.createElement('canvas');
+ const context = canvas.getContext('2d');
+ if (!context) continue;
+
+ context.font = `${testSize} ${font}, ${baseFont}`;
+ const baseWidth = context.measureText(testString).width;
+ context.font = `${testSize} ${baseFont}`;
+ const baseWidth2 = context.measureText(testString).width;
+
+ if (baseWidth !== baseWidth2) {
+ matched++;
+ }
+ }
+ if (matched >= 2) {
+ availableFonts.push(font);
+ }
+ }
+
+ return availableFonts;
+ }
+
+ public async sendFingerprintData() {
+ try {
+ const fingerprintData = await this.getFingerprintData();
+
+ const data: FingerprintData = {
+ timestamp: new Date().toISOString(),
+ ipAddress: '', // Will be set by server
+ ...fingerprintData
+ } as FingerprintData;
+
+ // Send to our tracking API
+ await fetch('/api/tracking/fingerprint', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify(data)
+ });
+
+ } catch (error) {
+ console.error('Error sending fingerprint data:', error);
+ }
+ }
+
+ public async trackPageView(pageUrl: string) {
+ try {
+ const fingerprintData = await this.getFingerprintData();
+
+ const data = {
+ ...fingerprintData,
+ timestamp: new Date().toISOString(),
+ pageUrl,
+ eventType: 'pageview'
+ };
+
+ await fetch('/api/tracking/fingerprint', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify(data)
+ });
+
+ } catch (error) {
+ console.error('Error tracking page view:', error);
+ }
+ }
+}
+
+// Create a singleton instance
+let fingerprintTracker: FingerprintTracker | null = null;
+
+export function getFingerprintTracker(): FingerprintTracker {
+ if (!fingerprintTracker) {
+ fingerprintTracker = new FingerprintTracker();
+ }
+ return fingerprintTracker;
+}
+
+export function initializeFingerprintTracking() {
+ if (typeof window !== 'undefined') {
+ getFingerprintTracker();
+ }
+}
\ No newline at end of file
diff --git a/src/lib/marketingIntelligence.ts b/src/lib/marketingIntelligence.ts
old mode 100644
new mode 100755
diff --git a/src/lib/nginxLogParser.ts b/src/lib/nginxLogParser.ts
old mode 100644
new mode 100755
index 7220c9b..edf90e3
--- a/src/lib/nginxLogParser.ts
+++ b/src/lib/nginxLogParser.ts
@@ -612,7 +612,7 @@ class NGINXLogParser {
return {
ipAddress,
- totalVisits: ipEntries.length,
+ totalVisits: sessions.length, // Changed from ipEntries.length to sessions.length
sessions: sessions.length,
averageTimeOnSite,
pages,
diff --git a/vercel-import-env.sh b/vercel-import-env.sh
old mode 100644
new mode 100755