geo main

app/api/events/devices/route.ts

@@ -6,10 +6,19 @@ export async function GET(request: NextRequest) {
   try {
     const searchParams = request.nextUrl.searchParams;
     
+    // 获取团队、项目和标签筛选参数
+    const teamIds = searchParams.getAll('teamId');
+    const projectIds = searchParams.getAll('projectId');
+    const tagIds = searchParams.getAll('tagId');
+    
     const data = await getDeviceAnalytics({
       startTime: searchParams.get('startTime') || undefined,
       endTime: searchParams.get('endTime') || undefined,
-      linkId: searchParams.get('linkId') || undefined
+      linkId: searchParams.get('linkId') || undefined,
+      // 添加团队、项目和标签筛选
+      teamIds: teamIds.length > 0 ? teamIds : undefined,
+      projectIds: projectIds.length > 0 ? projectIds : undefined,
+      tagIds: tagIds.length > 0 ? tagIds : undefined
     });
 
     const response: ApiResponse<typeof data> = {

app/api/events/geo/route.ts

@@ -6,11 +6,23 @@ export async function GET(request: NextRequest) {
   try {
     const searchParams = request.nextUrl.searchParams;
     
+    // 获取团队、项目和标签筛选参数
+    const teamIds = searchParams.getAll('teamId');
+    const projectIds = searchParams.getAll('projectId');
+    const tagIds = searchParams.getAll('tagId');
+    
+    // Get the groupBy parameter
+    const groupBy = searchParams.get('groupBy') as 'country' | 'city' | 'region' | 'continent' | null;
+    
     const data = await getGeoAnalytics({
       startTime: searchParams.get('startTime') || undefined,
       endTime: searchParams.get('endTime') || undefined,
       linkId: searchParams.get('linkId') || undefined,
-      groupBy: (searchParams.get('groupBy') || 'country') as 'country' | 'city'
+      groupBy: groupBy || undefined,
+      // 添加团队、项目和标签筛选
+      teamIds: teamIds.length > 0 ? teamIds : undefined,
+      projectIds: projectIds.length > 0 ? projectIds : undefined,
+      tagIds: tagIds.length > 0 ? tagIds : undefined
     });
 
     const response: ApiResponse<typeof data> = {

app/api/events/route.ts

@@ -35,10 +35,8 @@ export async function GET(request: NextRequest) {
       linkId,
       linkSlug,
       userId,
-      teamId: teamIds.length > 0 ? teamIds[0] : undefined,
-      teamIds: teamIds.length > 1 ? teamIds : undefined,
-      projectId: projectIds.length > 0 ? projectIds[0] : undefined,
-      projectIds: projectIds.length > 1 ? projectIds : undefined,
+      teamIds: teamIds.length > 0 ? teamIds : undefined,
+      projectIds: projectIds.length > 0 ? projectIds : undefined,
       tagIds: tagIds.length > 0 ? tagIds : undefined,
       startTime,
       endTime,

app/api/events/time-series/route.ts

@@ -15,11 +15,20 @@ export async function GET(request: NextRequest) {
       }, { status: 400 });
     }
     
+    // 获取团队、项目和标签筛选参数
+    const teamIds = searchParams.getAll('teamId');
+    const projectIds = searchParams.getAll('projectId');
+    const tagIds = searchParams.getAll('tagId');
+    
     const data = await getTimeSeriesData({
       startTime,
       endTime,
       linkId: searchParams.get('linkId') || undefined,
-      granularity: (searchParams.get('granularity') || 'day') as 'hour' | 'day' | 'week' | 'month'
+      granularity: (searchParams.get('granularity') || 'day') as 'hour' | 'day' | 'week' | 'month',
+      // 添加团队、项目和标签筛选
+      teamIds: teamIds.length > 0 ? teamIds : undefined,
+      projectIds: projectIds.length > 0 ? projectIds : undefined,
+      tagIds: tagIds.length > 0 ? tagIds : undefined
     });
 
     const response: ApiResponse<typeof data> = {

app/api/geo/batch/route.ts

@@ -0,0 +1,248 @@
+import { NextRequest, NextResponse } from 'next/server';
+import type { ApiResponse } from '@/lib/types';
+
+interface IpLocationData {
+  ip: string;
+  country_name: string;
+  country_code: string;
+  city: string;
+  region: string;
+  continent_code: string;
+  continent_name: string;
+  latitude: number;
+  longitude: number;
+  timestamp: number;
+}
+
+// Simple in-memory cache on the server side to reduce API calls
+const serverCache: Record<string, IpLocationData> = {};
+
+// Cache for IPs that have repeatedly failed to resolve
+const failedIPsCache: Record<string, { attempts: number, lastAttempt: number }> = {};
+
+// Cache expiration time (30 days in milliseconds)
+const CACHE_EXPIRATION = 30 * 24 * 60 * 60 * 1000; // 30 days
+
+// Max attempts to fetch an IP before considering it permanently failed
+const MAX_RETRY_ATTEMPTS = 3;
+
+// Retry timeout - how long to wait before trying a failed IP again (24 hours)
+const RETRY_TIMEOUT = 24 * 60 * 60 * 1000;
+
+/**
+ * Check if an IP has failed too many times and should be skipped
+ */
+function shouldSkipIP(ip: string): boolean {
+  if (!failedIPsCache[ip]) return false;
+  
+  const now = Date.now();
+  
+  // Skip if max attempts reached
+  if (failedIPsCache[ip].attempts >= MAX_RETRY_ATTEMPTS) {
+    return true;
+  }
+  
+  // Skip if last attempt was recent
+  if (now - failedIPsCache[ip].lastAttempt < RETRY_TIMEOUT) {
+    return true;
+  }
+  
+  return false;
+}
+
+/**
+ * Mark an IP as failed
+ */
+function markIPAsFailed(ip: string): void {
+  const now = Date.now();
+  
+  if (failedIPsCache[ip]) {
+    failedIPsCache[ip] = {
+      attempts: failedIPsCache[ip].attempts + 1,
+      lastAttempt: now
+    };
+  } else {
+    failedIPsCache[ip] = {
+      attempts: 1,
+      lastAttempt: now
+    };
+  }
+}
+
+/**
+ * Get location data for a single IP using ipapi.co
+ */
+async function fetchIpLocation(ip: string): Promise<IpLocationData | null> {
+  try {
+    // Skip this IP if it has failed too many times
+    if (shouldSkipIP(ip)) {
+      console.log(`[Server] Skipping blacklisted IP: ${ip}`);
+      return null;
+    }
+    
+    // Check server cache first
+    const now = Date.now();
+    if (serverCache[ip] && (now - serverCache[ip].timestamp) < CACHE_EXPIRATION) {
+      return serverCache[ip];
+    }
+    
+    // Add delay to avoid rate limiting (100 requests per minute max)
+    await new Promise(resolve => setTimeout(resolve, 600)); // ~100 req/min = 1 req per 600ms
+    
+    const response = await fetch(`https://ipapi.co/${ip}/json/`);
+    
+    if (!response.ok) {
+      console.error(`Error fetching location for IP ${ip}: ${response.statusText}`);
+      markIPAsFailed(ip);
+      return null;
+    }
+    
+    const data = await response.json();
+    
+    if (data.error) {
+      console.error(`Error fetching location for IP ${ip}: ${data.reason}`);
+      markIPAsFailed(ip);
+      return null;
+    }
+    
+    // Reset failed status if successful
+    if (failedIPsCache[ip]) {
+      delete failedIPsCache[ip];
+    }
+    
+    const locationData: IpLocationData = {
+      ip: data.ip,
+      country_name: data.country_name || 'Unknown',
+      country_code: data.country_code || 'UN',
+      city: data.city || 'Unknown',
+      region: data.region || 'Unknown',
+      continent_code: data.continent_code || 'UN',
+      continent_name: getContinentName(data.continent_code) || 'Unknown',
+      latitude: data.latitude || 0,
+      longitude: data.longitude || 0,
+      timestamp: Date.now()
+    };
+    
+    // Cache the result
+    serverCache[ip] = locationData;
+    
+    return locationData;
+  } catch (error) {
+    console.error(`Error fetching location for IP ${ip}:`, error);
+    markIPAsFailed(ip);
+    return null;
+  }
+}
+
+/**
+ * Get continent name from continent code
+ */
+function getContinentName(code?: string): string {
+  if (!code) return 'Unknown';
+  
+  const continents: Record<string, string> = {
+    'AF': 'Africa',
+    'AN': 'Antarctica',
+    'AS': 'Asia',
+    'EU': 'Europe',
+    'NA': 'North America',
+    'OC': 'Oceania',
+    'SA': 'South America'
+  };
+  
+  return continents[code] || 'Unknown';
+}
+
+/**
+ * API route handler for batch IP location lookups
+ */
+export async function POST(request: NextRequest) {
+  try {
+    const { ips } = await request.json();
+    
+    if (!ips || !Array.isArray(ips) || ips.length === 0) {
+      return NextResponse.json({
+        success: false,
+        error: 'Invalid or empty IP list'
+      }, { status: 400 });
+    }
+    
+    // Limit batch size to 50 IPs to prevent abuse
+    const ipList = ips.slice(0, 50);
+    const results: Record<string, IpLocationData | null> = {};
+    
+    // Filter out IPs that should be skipped
+    const validIPs = ipList.filter(ip => {
+      if (typeof ip !== 'string' || !ip.trim()) return false;
+      if (isPrivateIP(ip)) {
+        results[ip] = getPrivateIPData(ip);
+        return false;
+      }
+      if (shouldSkipIP(ip)) {
+        console.log(`[Server] Skipping blacklisted IP: ${ip}`);
+        results[ip] = null;
+        return false;
+      }
+      return true;
+    });
+    
+    // Process remaining IPs sequentially to respect rate limits
+    for (const ip of validIPs) {
+      results[ip] = await fetchIpLocation(ip);
+    }
+    
+    const response: ApiResponse<Record<string, IpLocationData | null>> = {
+      success: true,
+      data: results
+    };
+    
+    return NextResponse.json(response);
+  } catch (error) {
+    console.error('Batch IP lookup error:', error);
+    
+    const response: ApiResponse<null> = {
+      success: false,
+      error: error instanceof Error ? error.message : 'Unknown error occurred'
+    };
+    
+    return NextResponse.json(response, { status: 500 });
+  }
+}
+
+/**
+ * Check if IP is a private/local address
+ */
+function isPrivateIP(ip: string): boolean {
+  return (
+    ip.startsWith('10.') || 
+    ip.startsWith('192.168.') || 
+    ip.startsWith('172.16.') || 
+    ip.startsWith('172.17.') || 
+    ip.startsWith('172.18.') || 
+    ip.startsWith('172.19.') || 
+    ip.startsWith('172.20.') || 
+    ip.startsWith('172.21.') || 
+    ip.startsWith('172.22.') || 
+    ip.startsWith('127.') || 
+    ip === 'localhost' || 
+    ip === '::1'
+  );
+}
+
+/**
+ * Generate location data for private IP addresses
+ */
+function getPrivateIPData(ip: string): IpLocationData {
+  return {
+    ip,
+    country_name: 'Local Network',
+    country_code: 'LO',
+    city: 'Local',
+    region: 'Local',
+    continent_code: 'LO',
+    continent_name: 'Local',
+    latitude: 0,
+    longitude: 0,
+    timestamp: Date.now()
+  };
+} 

app/api/types.ts

@@ -94,6 +94,7 @@ export interface TimeSeriesData {
 
 export interface GeoData {
   location: string;
+  area: string;
   visits: number;
   visitors: number;
   percentage: number;

app/components/analytics/GeoAnalytics.tsx

@@ -1,12 +1,33 @@
 "use client";
 
+import { useState, useEffect } from 'react';
 import { GeoData } from '@/app/api/types';
+import { getLocationsFromIPs } from '@/app/utils/ipLocation';
 
 interface GeoAnalyticsProps {
   data: GeoData[];
 }
 
+// Interface for IP location data in our cache
+interface IpLocationDetail {
+  country: string;
+  city: string;
+  region: string;
+  continent: string;
+}
+
+// Cache for IP location data
+interface LocationCache {
+  [key: string]: IpLocationDetail;
+}
+
 export default function GeoAnalytics({ data }: GeoAnalyticsProps) {
+  const [viewMode, setViewMode] = useState<'country' | 'city' | 'region' | 'continent'>('country');
+  const [locationCache, setLocationCache] = useState<LocationCache>({});
+  const [isLoading, setIsLoading] = useState(false);
+  // Track IPs that failed to resolve
+  const [failedIPs, setFailedIPs] = useState<Set<string>>(new Set());
+
   // 安全地格式化数字
   const formatNumber = (value: number | undefined | null): string => {
     if (value === undefined || value === null) return '0';
@@ -21,52 +42,233 @@ export default function GeoAnalytics({ data }: GeoAnalyticsProps) {
 
   const sortedData = [...data].sort((a, b) => (b.visits || 0) - (a.visits || 0));
 
+  // Handle tab selection - only change local view mode
+  const handleViewModeChange = (mode: 'country' | 'city' | 'region' | 'continent') => {
+    setViewMode(mode);
+  };
+
+  // Load location data for all IPs when the data changes
+  useEffect(() => {
+    const fetchLocations = async () => {
+      if (sortedData.length === 0) return;
+      
+      setIsLoading(true);
+      const tempCache: LocationCache = {...locationCache};
+      const tempFailedIPs = new Set(failedIPs);
+      
+      // Get all unique IPs that aren't already in the cache and haven't failed
+      const uniqueIPs = [...new Set(sortedData.map(item => item.location))].filter(ip => 
+        ip && 
+        ip !== 'Unknown' && 
+        !tempCache[ip] && 
+        !tempFailedIPs.has(ip)
+      );
+      
+      if (uniqueIPs.length === 0) {
+        setIsLoading(false);
+        return;
+      }
+      
+      try {
+        // Use batch lookup for better performance
+        const batchResults = await getLocationsFromIPs(uniqueIPs);
+        
+        // Convert results to our cache format
+        for (const [ip, data] of Object.entries(batchResults)) {
+          if (data) {
+            tempCache[ip] = {
+              country: data.country_name,
+              city: data.city,
+              region: data.region,
+              continent: data.continent_name
+            };
+          } else {
+            // Mark as failed
+            tempFailedIPs.add(ip);
+          }
+        }
+        
+        setLocationCache(tempCache);
+        setFailedIPs(tempFailedIPs);
+      } catch (error) {
+        console.error('Error fetching location data:', error);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    
+    fetchLocations();
+  }, [data]);
+
+  // Get the appropriate location value based on the current view mode
+  const getLocationValue = (item: GeoData): string => {
+    const ip = item.location || '';
+    
+    // If there's no IP or it's "Unknown", return that value
+    if (!ip || ip === 'Unknown') return 'Unknown';
+    
+    // If IP failed to resolve, return Unknown
+    if (failedIPs.has(ip)) {
+      return 'Unknown';
+    }
+    
+    // Return from cache if available
+    if (locationCache[ip]) {
+      switch (viewMode) {
+        case 'country':
+          return locationCache[ip].country || 'Unknown';
+        case 'city':
+          return locationCache[ip].city || 'Unknown';
+        case 'region':
+          return locationCache[ip].region || 'Unknown';
+        case 'continent':
+          return locationCache[ip].continent || 'Unknown';
+        default:
+          return ip;
+      }
+    }
+    
+    // Return placeholder if not in cache yet
+    return `Loading...`;
+  };
+
+  // Get the appropriate area value based on the current view mode
+  const getAreaValue = (item: GeoData): string => {
+    const ip = item.location || '';
+    
+    // If there's no IP or it's "Unknown", return empty string
+    if (!ip || ip === 'Unknown' || failedIPs.has(ip)) return '';
+    
+    // Return from cache if available
+    if (locationCache[ip]) {
+      switch (viewMode) {
+        case 'country':
+          // For country view, show the continent as area
+          return locationCache[ip].continent || '';
+        case 'city':
+          // For city view, show the country and region
+          return `${locationCache[ip].country}, ${locationCache[ip].region}`;
+        case 'region':
+          // For region view, show the country
+          return locationCache[ip].country || '';
+        case 'continent':
+          // For continent view, no additional area needed
+          return '';
+        default:
+          return '';
+      }
+    }
+    
+    // Return empty if not in cache yet
+    return '';
+  };
+
   return (
-    <div className="overflow-x-auto">
-      <table className="min-w-full divide-y divide-gray-200">
-        <thead className="bg-gray-50">
-          <tr>
-            <th scope="col" className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
-              Location
-            </th>
-            <th scope="col" className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
-              Visits
-            </th>
-            <th scope="col" className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
-              Unique Visitors
-            </th>
-            <th scope="col" className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
-              % of Total
-            </th>
-          </tr>
-        </thead>
-        <tbody className="bg-white divide-y divide-gray-200">
-          {sortedData.map((item, index) => (
-            <tr key={index} className={index % 2 === 0 ? 'bg-white' : 'bg-gray-50'}>
-              <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
-                {item.location || 'Unknown'}
-              </td>
-              <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
-                {formatNumber(item.visits)}
-              </td>
-              <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
-                {formatNumber(item.visitors)}
-              </td>
-              <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
-                <div className="flex items-center">
-                  <div className="w-24 bg-gray-200 rounded-full h-2">
-                    <div
-                      className="bg-blue-600 h-2 rounded-full"
-                      style={{ width: `${item.percentage || 0}%` }}
-                    />
-                  </div>
-                  <span className="ml-2">{formatPercent(item.percentage)}%</span>
-                </div>
-              </td>
+    <div>
+      {/* Tabs for geographic levels */}
+      <div className="flex border-b mb-6">
+        <button 
+          onClick={() => handleViewModeChange('country')}
+          className={`px-4 py-2 ${viewMode === 'country' ? 'border-b-2 border-blue-500 text-blue-600' : 'text-gray-500'}`}
+        >
+          Countries
+        </button>
+        <button 
+          onClick={() => handleViewModeChange('city')}
+          className={`px-4 py-2 ${viewMode === 'city' ? 'border-b-2 border-blue-500 text-blue-600' : 'text-gray-500'}`}
+        >
+          Cities
+        </button>
+        <button 
+          onClick={() => handleViewModeChange('region')}
+          className={`px-4 py-2 ${viewMode === 'region' ? 'border-b-2 border-blue-500 text-blue-600' : 'text-gray-500'}`}
+        >
+          Regions
+        </button>
+        <button 
+          onClick={() => handleViewModeChange('continent')}
+          className={`px-4 py-2 ${viewMode === 'continent' ? 'border-b-2 border-blue-500 text-blue-600' : 'text-gray-500'}`}
+        >
+          Continents
+        </button>
+      </div>
+
+      {/* Loading indicator */}
+      {isLoading && (
+        <div className="flex justify-center items-center py-2 mb-4">
+          <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-blue-500 mr-2"></div>
+          <span className="text-sm text-gray-500">Loading location data...</span>
+        </div>
+      )}
+
+      {/* Table with added area column */}
+      <div className="overflow-x-auto">
+        <table className="min-w-full divide-y divide-gray-200">
+          <thead className="bg-gray-50">
+            <tr>
+              <th scope="col" className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                {viewMode === 'country' ? 'Country' : 
+                 viewMode === 'city' ? 'City' : 
+                 viewMode === 'region' ? 'Region' : 'Continent'}
+              </th>
+              <th scope="col" className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                {viewMode === 'country' ? 'Continent' : 
+                 viewMode === 'city' ? 'Location' : 
+                 viewMode === 'region' ? 'Country' : 'Area'}
+              </th>
+              <th scope="col" className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                Visits
+              </th>
+              <th scope="col" className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                Unique Visitors
+              </th>
+              <th scope="col" className="px-6 py-3 text-left text-xs font-medium text-gray-500 uppercase tracking-wider">
+                % of Total
+              </th>
             </tr>
-          ))}
-        </tbody>
-      </table>
+          </thead>
+          <tbody className="bg-white divide-y divide-gray-200">
+            {sortedData.length > 0 ? (
+              sortedData.map((item, index) => (
+                <tr key={index} className={index % 2 === 0 ? 'bg-white' : 'bg-gray-50'}>
+                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
+                    {getLocationValue(item)}
+                    {item.location && (
+                      <div className="text-xs text-gray-500 mt-1">{item.location}</div>
+                    )}
+                  </td>
+                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-500">
+                    {getAreaValue(item)}
+                  </td>
+                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
+                    {formatNumber(item.visits)}
+                  </td>
+                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
+                    {formatNumber(item.visitors)}
+                  </td>
+                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900">
+                    <div className="flex items-center">
+                      <div className="w-24 bg-gray-200 rounded-full h-2">
+                        <div
+                          className="bg-blue-600 h-2 rounded-full"
+                          style={{ width: `${item.percentage || 0}%` }}
+                        />
+                      </div>
+                      <span className="ml-2">{formatPercent(item.percentage)}%</span>
+                    </div>
+                  </td>
+                </tr>
+              ))
+            ) : (
+              <tr>
+                <td colSpan={5} className="px-6 py-4 text-center text-sm text-gray-500">
+                  No location data available
+                </td>
+              </tr>
+            )}
+          </tbody>
+        </table>
+      </div>
     </div>
   );
 } 

app/components/ipLocationTest.tsx

@@ -0,0 +1,100 @@
+"use client";
+
+import { useState, useEffect } from 'react';
+import { getLocationFromIP } from '@/app/utils/ipLocation';
+
+interface LocationData {
+  ip: string;
+  country_name: string;
+  country_code: string;
+  city: string;
+  region: string;
+  continent_code: string;
+  continent_name: string;
+  latitude: number;
+  longitude: number;
+}
+
+export default function IpLocationTest() {
+  const [locationData, setLocationData] = useState<LocationData | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  
+  const testIp = "120.244.39.90";
+  
+  useEffect(() => {
+    async function fetchLocation() {
+      try {
+        setLoading(true);
+        setError(null);
+        
+        const data = await getLocationFromIP(testIp);
+        setLocationData(data);
+        
+      } catch (err) {
+        setError(err instanceof Error ? err.message : 'Unknown error occurred');
+      } finally {
+        setLoading(false);
+      }
+    }
+    
+    fetchLocation();
+  }, []);
+  
+  return (
+    <div className="p-4 bg-white rounded-lg shadow">
+      <h2 className="text-lg font-semibold mb-4">IP Location Test: {testIp}</h2>
+      
+      {loading && (
+        <div className="flex items-center text-gray-500">
+          <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-blue-500 mr-2"></div>
+          Loading location data...
+        </div>
+      )}
+      
+      {error && (
+        <div className="text-red-500">
+          Error: {error}
+        </div>
+      )}
+      
+      {!loading && locationData && (
+        <div className="space-y-4">
+          <div>
+            <h3 className="font-medium">Location Data:</h3>
+            <pre className="mt-2 p-4 bg-gray-100 rounded overflow-auto">
+              {JSON.stringify(locationData, null, 2)}
+            </pre>
+          </div>
+          
+          <div className="grid grid-cols-2 gap-4">
+            <div className="border p-3 rounded">
+              <h4 className="font-medium">Country</h4>
+              <div>{locationData.country_name} ({locationData.country_code})</div>
+            </div>
+            
+            <div className="border p-3 rounded">
+              <h4 className="font-medium">City</h4>
+              <div>{locationData.city || 'N/A'}</div>
+            </div>
+            
+            <div className="border p-3 rounded">
+              <h4 className="font-medium">Region</h4>
+              <div>{locationData.region || 'N/A'}</div>
+            </div>
+            
+            <div className="border p-3 rounded">
+              <h4 className="font-medium">Continent</h4>
+              <div>{locationData.continent_name} ({locationData.continent_code})</div>
+            </div>
+            
+            <div className="border p-3 rounded col-span-2">
+              <h4 className="font-medium">Coordinates</h4>
+              <div>Latitude: {locationData.latitude}, Longitude: {locationData.longitude}</div>
+            </div>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+} 

app/components/ui/ProjectSelector.tsx

@@ -35,12 +35,14 @@ export function ProjectSelector({
   className,
   multiple = false,
   teamId,
+  teamIds,
 }: { 
   value?: string | string[];
   onChange?: (projectId: string | string[]) => void;
   className?: string;
   multiple?: boolean;
   teamId?: string; // Optional team ID to filter projects by team
+  teamIds?: string[]; // Optional array of team IDs to filter projects by multiple teams
 }) {
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
@@ -49,6 +51,16 @@ export function ProjectSelector({
   const [isOpen, setIsOpen] = useState(false);
   const selectorRef = useRef<HTMLDivElement>(null);
 
+  // Normalize team IDs to ensure we're always working with an array
+  const effectiveTeamIds = React.useMemo(() => {
+    if (teamIds && teamIds.length > 0) {
+      return teamIds;
+    } else if (teamId) {
+      return [teamId];
+    }
+    return undefined;
+  }, [teamId, teamIds]);
+
   // Initialize selected projects based on value prop
   useEffect(() => {
     if (value) {
@@ -90,38 +102,59 @@ export function ProjectSelector({
       try {
         const supabase = getSupabaseClient();
         
-        let projectsQuery;
-        
-        if (teamId) {
-          // 如果提供了teamId，获取该团队的项目
-          projectsQuery = supabase
+        if (effectiveTeamIds && effectiveTeamIds.length > 0) {
+          // If team IDs are provided, get projects for those teams
+          const { data: projectsData, error: projectsError } = await supabase
             .from('team_projects')
             .select('project_id, projects:project_id(*), teams:team_id(name)')
-            .eq('team_id', teamId)
+            .in('team_id', effectiveTeamIds)
             .is('projects.deleted_at', null);
+
+          if (projectsError) throw projectsError;
+
+          if (!projectsData || projectsData.length === 0) {
+            if (isMounted) setProjects([]);
+            return;
+          }
+
+          // Extract projects from response with team info
+          if (isMounted) {
+            const projectList: Project[] = [];
+            
+            for (const item of projectsData as ProjectWithTeam[]) {
+              if (item.projects && typeof item.projects === 'object' && 'id' in item.projects && 'name' in item.projects) {
+                const project = item.projects as Project;
+                if (item.teams && 'name' in item.teams) {
+                  project.team_name = item.teams.name;
+                }
+                // Avoid duplicate projects from different teams
+                if (!projectList.some(p => p.id === project.id)) {
+                  projectList.push(project);
+                }
+              }
+            }
+            
+            setProjects(projectList);
+          }
         } else {
-          // 否则，获取用户所属的所有项目及其所属团队
-          projectsQuery = supabase
+          // If no team IDs, get all user's projects
+          const { data: projectsData, error: projectsError } = await supabase
             .from('user_projects')
             .select('project_id, projects:project_id(*)')
             .eq('user_id', userId)
             .is('projects.deleted_at', null);
-        }
 
-        const { data: projectsData, error: projectsError } = await projectsQuery;
+          if (projectsError) throw projectsError;
 
-        if (projectsError) throw projectsError;
+          if (!projectsData || projectsData.length === 0) {
+            if (isMounted) setProjects([]);
+            return;
+          }
 
-        if (!projectsData || projectsData.length === 0) {
-          if (isMounted) setProjects([]);
-          return;
-        }
-
-        // 如果没有提供teamId，需要单独获取每个项目对应的团队信息
-        if (!teamId && projectsData.length > 0) {
+          // Fetch team info for these projects
           const projectIds = projectsData.map(item => item.project_id);
           
-          // 获取项目所属的团队信息
+          // Get team info for each project
           const { data: teamProjectsData, error: teamProjectsError } = await supabase
             .from('team_projects')
             .select('project_id, teams:team_id(name)')
@@ -129,7 +162,7 @@ export function ProjectSelector({
             
           if (teamProjectsError) throw teamProjectsError;
           
-          // 创建项目ID到团队名称的映射
+          // Create project ID to team name mapping
           const projectTeamMap: Record<string, string> = {};
           if (teamProjectsData) {
             teamProjectsData.forEach(item => {
@@ -139,7 +172,7 @@ export function ProjectSelector({
             });
           }
           
-          // 提取项目数据，并添加团队名称
+          // Extract projects with team names
           if (isMounted && projectsData) {
             const projectList: Project[] = [];
             
@@ -151,23 +184,6 @@ export function ProjectSelector({
               }
             }
             
-            setProjects(projectList);
-          }
-        } else {
-          // 如果提供了teamId，直接从查询结果中提取项目和团队信息
-          if (isMounted && projectsData) {
-            const projectList: Project[] = [];
-            
-            for (const item of projectsData as ProjectWithTeam[]) {
-              if (item.projects && typeof item.projects === 'object' && 'id' in item.projects && 'name' in item.projects) {
-                const project = item.projects as Project;
-                if (item.teams && 'name' in item.teams) {
-                  project.team_name = item.teams.name;
-                }
-                projectList.push(project);
-              }
-            }
-            
             setProjects(projectList);
           }
         }
@@ -203,7 +219,7 @@ export function ProjectSelector({
       isMounted = false;
       subscription.unsubscribe();
     };
-  }, [teamId]);
+  }, [effectiveTeamIds]);
 
   const handleToggle = () => {
     if (!loading && !error && projects.length > 0) {

app/components/ui/TagSelector.tsx

@@ -30,14 +30,14 @@ export function TagSelector({
   className,
   multiple = false,
   teamId,
-  tagType,
+  teamIds,
 }: { 
   value?: string | string[];
-  onChange?: (tagId: string | string[]) => void;
+  onChange?: (tagIds: string | string[]) => void;
   className?: string;
   multiple?: boolean;
-  teamId?: string; // Optional team ID to filter tags by team
-  tagType?: string; // Optional tag type for filtering
+  teamId?: string; // Optional single team ID
+  teamIds?: string[]; // Optional array of team IDs
 }) {
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
@@ -46,6 +46,16 @@ export function TagSelector({
   const [isOpen, setIsOpen] = useState(false);
   const selectorRef = useRef<HTMLDivElement>(null);
 
+  // Normalize team IDs to ensure we're always working with an array
+  const effectiveTeamIds = React.useMemo(() => {
+    if (teamIds && teamIds.length > 0) {
+      return teamIds;
+    } else if (teamId) {
+      return [teamId];
+    }
+    return undefined;
+  }, [teamId, teamIds]);
+
   // 标签名称与ID的映射函数
   const getTagIdByName = (name: string): string | undefined => {
     const tag = tags.find(t => t.name === name);
@@ -119,13 +129,8 @@ export function TagSelector({
         let query = supabase.from('tags').select('*').is('deleted_at', null);
         
         // Filter by team if teamId is provided
-        if (teamId) {
-          query = query.eq('team_id', teamId);
-        }
-        
-        // Filter by tag type if provided
-        if (tagType) {
-          query = query.eq('type', tagType);
+        if (effectiveTeamIds) {
+          query = query.in('team_id', effectiveTeamIds);
         }
         
         const { data: tagsData, error: tagsError } = await query;
@@ -170,7 +175,7 @@ export function TagSelector({
       isMounted = false;
       subscription.unsubscribe();
     };
-  }, [teamId, tagType]);
+  }, [effectiveTeamIds]);
 
   const handleToggle = () => {
     if (!loading && !error && tags.length > 0) {

app/ip-test/page.tsx

@@ -0,0 +1,10 @@
+import IpLocationTest from '../components/ipLocationTest';
+
+export default function IpTestPage() {
+  return (
+    <div className="container mx-auto p-4 max-w-4xl">
+      <h1 className="text-2xl font-bold mb-6">IP to Location Test</h1>
+      <IpLocationTest />
+    </div>
+  );
+} 

app/page.tsx

@@ -248,7 +248,18 @@ export default function HomePage() {
         <div className="flex flex-col gap-4 md:flex-row md:items-center">
           <TeamSelector
             value={selectedTeamIds}
-            onChange={(value) => setSelectedTeamIds(Array.isArray(value) ? value : [value])}
+            onChange={(value) => {
+              const newTeamIds = Array.isArray(value) ? value : [value];
+              
+              // Check if team selection has changed
+              if (JSON.stringify(newTeamIds) !== JSON.stringify(selectedTeamIds)) {
+                // Clear project selection when team changes
+                setSelectedProjectIds([]);
+                
+                // Update team selection
+                setSelectedTeamIds(newTeamIds);
+              }
+            }}
             className="w-[250px]"
             multiple={true}
           />
@@ -257,14 +268,14 @@ export default function HomePage() {
             onChange={(value) => setSelectedProjectIds(Array.isArray(value) ? value : [value])}
             className="w-[250px]"
             multiple={true}
-            teamId={selectedTeamIds.length === 1 ? selectedTeamIds[0] : undefined}
+            teamIds={selectedTeamIds.length > 0 ? selectedTeamIds : undefined}
           />
           <TagSelector
             value={selectedTagIds}
             onChange={(value) => setSelectedTagIds(Array.isArray(value) ? value : [value])}
             className="w-[250px]"
             multiple={true}
-            teamId={selectedTeamIds.length === 1 ? selectedTeamIds[0] : undefined}
+            teamIds={selectedTeamIds.length > 0 ? selectedTeamIds : undefined}
           />
           <DateRangePicker
             value={dateRange}
@@ -751,8 +762,41 @@ export default function HomePage() {
 
         <div className="bg-white rounded-lg shadow p-6 mb-8">
           <h2 className="text-lg font-semibold text-gray-900 mb-4">Geographic Distribution</h2>
-          <GeoAnalytics data={geoData} />
-      </div>
+          <GeoAnalytics 
+            data={geoData} 
+            onViewModeChange={(mode) => {
+              // 构建查询参数
+              const params = new URLSearchParams({
+                startTime: format(dateRange.from, "yyyy-MM-dd'T'HH:mm:ss'Z'"),
+                endTime: format(dateRange.to, "yyyy-MM-dd'T'HH:mm:ss'Z'"),
+                groupBy: mode
+              });
+              
+              // 添加其他筛选参数
+              if (selectedTeamIds.length > 0) {
+                selectedTeamIds.forEach(id => params.append('teamId', id));
+              }
+              
+              if (selectedProjectIds.length > 0) {
+                selectedProjectIds.forEach(id => params.append('projectId', id));
+              }
+              
+              if (selectedTagIds.length > 0) {
+                selectedTagIds.forEach(id => params.append('tagId', id));
+              }
+              
+              // 刷新地理位置数据
+              fetch(`/api/events/geo?${params}`)
+                .then(res => res.json())
+                .then(data => {
+                  if (data.success) {
+                    setGeoData(data.data);
+                  }
+                })
+                .catch(error => console.error('Failed to fetch geo data:', error));
+            }}
+          />
+        </div>
       </>
     </div>
   );

app/utils/ipLocation.ts

@@ -0,0 +1,484 @@
+interface IpLocationData {
+  ip: string;
+  country_name: string;
+  country_code: string;
+  city: string;
+  region: string;
+  continent_code: string;
+  continent_name: string;
+  latitude: number;
+  longitude: number;
+  timestamp?: number; // When this data was fetched
+}
+
+// In-memory cache
+let locationCache: Record<string, IpLocationData> = {};
+
+// Blacklist for IPs that failed to resolve multiple times
+let failedIPs: Record<string, { attempts: number, lastAttempt: number }> = {};
+
+// Cache expiration time (30 days in milliseconds)
+const CACHE_EXPIRATION = 30 * 24 * 60 * 60 * 1000;
+
+// Max retries for a failed IP
+const MAX_RETRY_ATTEMPTS = 3;
+
+// Retry timeout (24 hours in milliseconds)
+const RETRY_TIMEOUT = 24 * 60 * 60 * 1000;
+
+// Max number of IPs to batch in a single request
+const MAX_BATCH_SIZE = 10;
+
+/**
+ * Initialize cache from localStorage
+ */
+const initializeCache = () => {
+  if (typeof window === 'undefined') return;
+  
+  try {
+    // Load location cache
+    const cachedData = localStorage.getItem('ip-location-cache');
+    if (cachedData) {
+      const parsedCache = JSON.parse(cachedData);
+      
+      // Filter out expired entries
+      const now = Date.now();
+      const validEntries = Object.entries(parsedCache).filter(([, data]) => {
+        const entry = data as IpLocationData;
+        return entry.timestamp && now - entry.timestamp < CACHE_EXPIRATION;
+      });
+      
+      locationCache = Object.fromEntries(validEntries) as Record<string, IpLocationData>;
+      console.log(`Loaded ${validEntries.length} IP locations from cache`);
+    }
+    
+    // Load failed IPs
+    const failedIPsData = localStorage.getItem('ip-location-blacklist');
+    if (failedIPsData) {
+      const parsedFailedIPs = JSON.parse(failedIPsData);
+      
+      // Filter out expired blacklist entries
+      const now = Date.now();
+      const validFailedEntries = Object.entries(parsedFailedIPs).filter(([, data]) => {
+        const entry = data as { attempts: number, lastAttempt: number };
+        // Keep entries that have max attempts or haven't timed out yet
+        return entry.attempts >= MAX_RETRY_ATTEMPTS || 
+               now - entry.lastAttempt < RETRY_TIMEOUT;
+      });
+      
+      failedIPs = Object.fromEntries(validFailedEntries) as Record<string, { attempts: number, lastAttempt: number }>;
+      console.log(`Loaded ${validFailedEntries.length} blacklisted IPs`);
+    }
+  } catch (error) {
+    console.error('Failed to load IP location cache:', error);
+    // Reset cache if corrupted
+    localStorage.removeItem('ip-location-cache');
+    localStorage.removeItem('ip-location-blacklist');
+    locationCache = {};
+    failedIPs = {};
+  }
+};
+
+/**
+ * Save cache to localStorage
+ */
+const saveCache = () => {
+  if (typeof window === 'undefined') return;
+  
+  try {
+    localStorage.setItem('ip-location-cache', JSON.stringify(locationCache));
+  } catch (error) {
+    console.error('Failed to save IP location cache:', error);
+    
+    // If localStorage is full, clear old entries
+    if (error instanceof DOMException && error.name === 'QuotaExceededError') {
+      // Clear older entries - keep newest 100
+      const entries = Object.entries(locationCache)
+        .sort((a, b) => {
+          const timestampA = (a[1].timestamp || 0);
+          const timestampB = (b[1].timestamp || 0);
+          return timestampB - timestampA;
+        })
+        .slice(0, 100);
+      
+      locationCache = Object.fromEntries(entries);
+      localStorage.setItem('ip-location-cache', JSON.stringify(locationCache));
+    }
+  }
+};
+
+/**
+ * Save failed IPs to localStorage
+ */
+const saveFailedIPs = () => {
+  if (typeof window === 'undefined') return;
+  
+  try {
+    localStorage.setItem('ip-location-blacklist', JSON.stringify(failedIPs));
+  } catch (error) {
+    console.error('Failed to save IP blacklist:', error);
+    
+    // If localStorage is full, limit the size
+    if (error instanceof DOMException && error.name === 'QuotaExceededError') {
+      // Keep only IPs with max attempts
+      const entries = Object.entries(failedIPs)
+        .filter(([, data]) => data.attempts >= MAX_RETRY_ATTEMPTS);
+      
+      failedIPs = Object.fromEntries(entries);
+      localStorage.setItem('ip-location-blacklist', JSON.stringify(failedIPs));
+    }
+  }
+};
+
+/**
+ * Check if IP is a private/local address
+ */
+const isPrivateIP = (ip: string): boolean => {
+  return (
+    ip.startsWith('10.') || 
+    ip.startsWith('192.168.') || 
+    ip.startsWith('172.16.') || 
+    ip.startsWith('172.17.') || 
+    ip.startsWith('172.18.') || 
+    ip.startsWith('172.19.') || 
+    ip.startsWith('172.20.') || 
+    ip.startsWith('172.21.') || 
+    ip.startsWith('172.22.') || 
+    ip.startsWith('127.') || 
+    ip === 'localhost' || 
+    ip === '::1'
+  );
+};
+
+/**
+ * Check if an IP should be skipped (blacklisted)
+ */
+const shouldSkipIP = (ip: string): boolean => {
+  // If not in failed list, don't skip
+  if (!failedIPs[ip]) return false;
+  
+  const now = Date.now();
+  
+  // If reached max attempts, skip
+  if (failedIPs[ip].attempts >= MAX_RETRY_ATTEMPTS) {
+    return true;
+  }
+  
+  // If hasn't been long enough since last attempt, skip
+  if (now - failedIPs[ip].lastAttempt < RETRY_TIMEOUT) {
+    return true;
+  }
+  
+  // Otherwise, we can try again
+  return false;
+};
+
+/**
+ * Mark IP as failed
+ */
+const markIPAsFailed = (ip: string): void => {
+  const now = Date.now();
+  
+  if (failedIPs[ip]) {
+    failedIPs[ip] = {
+      attempts: failedIPs[ip].attempts + 1,
+      lastAttempt: now
+    };
+  } else {
+    failedIPs[ip] = {
+      attempts: 1,
+      lastAttempt: now
+    };
+  }
+  
+  saveFailedIPs();
+};
+
+/**
+ * Get location data for a single IP address
+ */
+const fetchSingleIP = async (ip: string): Promise<IpLocationData | null> => {
+  // Skip blacklisted IPs
+  if (shouldSkipIP(ip)) {
+    console.log(`Skipping blacklisted IP: ${ip}`);
+    return null;
+  }
+  
+  try {
+    const response = await fetch(`https://ipapi.co/${ip}/json/`);
+    
+    if (!response.ok) {
+      console.error(`Error fetching location for IP ${ip}: ${response.statusText}`);
+      markIPAsFailed(ip);
+      return null;
+    }
+    
+    const data = await response.json();
+    
+    if (data.error) {
+      console.error(`Error fetching location for IP ${ip}: ${data.reason}`);
+      markIPAsFailed(ip);
+      return null;
+    }
+    
+    // Reset failed attempts if successful
+    if (failedIPs[ip]) {
+      delete failedIPs[ip];
+      saveFailedIPs();
+    }
+    
+    const locationData: IpLocationData = {
+      ip: data.ip,
+      country_name: data.country_name || 'Unknown',
+      country_code: data.country_code || 'UN',
+      city: data.city || 'Unknown',
+      region: data.region || 'Unknown',
+      continent_code: data.continent_code || 'UN',
+      continent_name: getContinentName(data.continent_code) || 'Unknown',
+      latitude: data.latitude || 0,
+      longitude: data.longitude || 0,
+      timestamp: Date.now()
+    };
+    
+    return locationData;
+  } catch (error) {
+    console.error(`Error fetching location for IP ${ip}:`, error);
+    markIPAsFailed(ip);
+    return null;
+  }
+};
+
+/**
+ * Batch process multiple IPs at once using our own API endpoint
+ * This is a placeholder - we'll create a server API route for this
+ */
+const fetchBatchIPs = async (ips: string[]): Promise<Record<string, IpLocationData | null>> => {
+  try {
+    // Filter out blacklisted IPs
+    const validIPs = ips.filter(ip => !shouldSkipIP(ip));
+    
+    if (validIPs.length === 0) {
+      return {};
+    }
+    
+    const response = await fetch('/api/geo/batch', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ ips: validIPs }),
+    });
+    
+    if (!response.ok) {
+      throw new Error(`Batch request failed: ${response.statusText}`);
+    }
+    
+    const results = await response.json();
+    
+    // Mark failed IPs from results
+    for (const [ip, data] of Object.entries(results.data)) {
+      if (!data) {
+        markIPAsFailed(ip);
+      } else if (failedIPs[ip]) {
+        // Reset failed attempts if successful
+        delete failedIPs[ip];
+      }
+    }
+    
+    saveFailedIPs();
+    return results.data;
+  } catch (error) {
+    console.error('Error in batch IP lookup:', error);
+    
+    // Fallback to individual requests
+    const results: Record<string, IpLocationData | null> = {};
+    for (const ip of ips) {
+      // Skip blacklisted IPs
+      if (shouldSkipIP(ip)) {
+        results[ip] = null;
+        continue;
+      }
+      
+      // Add delays between requests to avoid rate limiting
+      await new Promise(resolve => setTimeout(resolve, 200));
+      results[ip] = await fetchSingleIP(ip);
+    }
+    return results;
+  }
+};
+
+/**
+ * Handle private IP addresses
+ */
+const getPrivateIPData = (ip: string): IpLocationData => ({
+  ip,
+  country_name: 'Local Network',
+  country_code: 'LO',
+  city: 'Local',
+  region: 'Local',
+  continent_code: 'LO',
+  continent_name: 'Local',
+  latitude: 0,
+  longitude: 0,
+  timestamp: Date.now()
+});
+
+/**
+ * Convert an IP address to location information
+ * Individual lookup for a single IP
+ */
+export async function getLocationFromIP(ip: string): Promise<IpLocationData | null> {
+  // Initialize cache from localStorage if needed
+  if (Object.keys(locationCache).length === 0) {
+    initializeCache();
+  }
+  
+  // Handle private IP addresses
+  if (isPrivateIP(ip)) {
+    const privateIPData = getPrivateIPData(ip);
+    locationCache[ip] = privateIPData;
+    return privateIPData;
+  }
+  
+  // Skip blacklisted IPs
+  if (shouldSkipIP(ip)) {
+    console.log(`Skipping blacklisted IP: ${ip}`);
+    return null;
+  }
+
+  // Return from cache if available and not expired
+  if (locationCache[ip]) {
+    const cachedData = locationCache[ip];
+    const now = Date.now();
+    
+    // Return cached data if not expired
+    if (cachedData.timestamp && now - cachedData.timestamp < CACHE_EXPIRATION) {
+      return cachedData;
+    }
+  }
+
+  // Fetch new data
+  const locationData = await fetchSingleIP(ip);
+  
+  // Save to cache if successful
+  if (locationData) {
+    locationCache[ip] = locationData;
+    saveCache();
+  }
+  
+  return locationData;
+}
+
+/**
+ * Batch lookup for multiple IPs at once
+ * More efficient than calling getLocationFromIP multiple times
+ */
+export async function getLocationsFromIPs(ips: string[]): Promise<Record<string, IpLocationData | null>> {
+  // Initialize cache from localStorage if needed
+  if (Object.keys(locationCache).length === 0) {
+    initializeCache();
+  }
+  
+  // Filter out IPs that are already in cache and not expired
+  const now = Date.now();
+  const cachedResults: Record<string, IpLocationData> = {};
+  const ipsToFetch: string[] = [];
+  
+  for (const ip of ips) {
+    // Handle private IPs
+    if (isPrivateIP(ip)) {
+      cachedResults[ip] = getPrivateIPData(ip);
+      continue;
+    }
+    
+    // Skip blacklisted IPs
+    if (shouldSkipIP(ip)) {
+      console.log(`Skipping blacklisted IP: ${ip}`);
+      continue;
+    }
+    
+    // Check cache
+    if (locationCache[ip] && locationCache[ip].timestamp && 
+        now - locationCache[ip].timestamp < CACHE_EXPIRATION) {
+      cachedResults[ip] = locationCache[ip];
+    } else {
+      ipsToFetch.push(ip);
+    }
+  }
+  
+  // If all IPs were cached or blacklisted, return immediately
+  if (ipsToFetch.length === 0) {
+    return cachedResults;
+  }
+  
+  // Process IPs in batches to avoid overwhelming the API
+  const results: Record<string, IpLocationData | null> = { ...cachedResults };
+  
+  // Process in smaller batches (e.g., 10 IPs at a time)
+  for (let i = 0; i < ipsToFetch.length; i += MAX_BATCH_SIZE) {
+    const batchIPs = ipsToFetch.slice(i, i + MAX_BATCH_SIZE);
+    
+    // Batch request
+    const batchResults = await fetchBatchIPs(batchIPs);
+    
+    // Update results and cache
+    for (const [ip, data] of Object.entries(batchResults)) {
+      results[ip] = data;
+      if (data) {
+        locationCache[ip] = data;
+      }
+    }
+    
+    // Save updated cache
+    saveCache();
+    
+    // Add delay between batches
+    if (i + MAX_BATCH_SIZE < ipsToFetch.length) {
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+  }
+  
+  return results;
+}
+
+/**
+ * Get continent name from continent code
+ */
+function getContinentName(code?: string): string {
+  if (!code) return 'Unknown';
+  
+  const continents: Record<string, string> = {
+    'AF': 'Africa',
+    'AN': 'Antarctica',
+    'AS': 'Asia',
+    'EU': 'Europe',
+    'NA': 'North America',
+    'OC': 'Oceania',
+    'SA': 'South America'
+  };
+  
+  return continents[code] || 'Unknown';
+}
+
+/**
+ * Get location information based on view mode
+ */
+export function getLocationByType(
+  locationData: IpLocationData | null, 
+  viewMode: 'country' | 'city' | 'region' | 'continent'
+): string {
+  if (!locationData) return 'Unknown';
+  
+  switch (viewMode) {
+    case 'country':
+      return locationData.country_name || 'Unknown';
+    case 'city':
+      return locationData.city || 'Unknown';
+    case 'region':
+      return locationData.region || 'Unknown';
+    case 'continent':
+      return locationData.continent_name || 'Unknown';
+    default:
+      return 'Unknown';
+  }
+} 

lib/analytics.ts

@@ -181,6 +181,9 @@ export async function getTimeSeriesData(params: {
   endTime: string;
   linkId?: string;
   granularity: 'hour' | 'day' | 'week' | 'month';
+  teamIds?: string[];
+  projectIds?: string[];
+  tagIds?: string[];
 }): Promise<TimeSeriesData[]> {
   const filter = buildFilter(params);
   
@@ -212,23 +215,33 @@ export async function getGeoAnalytics(params: {
   startTime?: string;
   endTime?: string;
   linkId?: string;
-  groupBy?: 'country' | 'city';
+  groupBy?: 'country' | 'city' | 'region' | 'continent';
+  teamIds?: string[];
+  projectIds?: string[];
+  tagIds?: string[];
 }): Promise<GeoData[]> {
   const filter = buildFilter(params);
-  const groupByField = 'ip_address'; // 暂时按 IP 地址分组
+  
+  // Choose grouping field based on selected view
+  let groupByField = 'country';
+  if (params.groupBy === 'city') groupByField = 'city';
+  else if (params.groupBy === 'region') groupByField = 'region';
+  else if (params.groupBy === 'continent') groupByField = 'continent';
+  else if (!params.groupBy) groupByField = 'ip_address'; // Default to IP address if no groupBy is specified
   
   const query = `
     SELECT
-      ${groupByField} as location,
+      COALESCE(${groupByField}, 'Unknown') as location,
+      '' as area, /* Area column - empty for now */
       count() as visits,
       uniq(ip_address) as visitors,
       count() * 100.0 / sum(count()) OVER () as percentage
     FROM events
     ${filter}
-    GROUP BY ${groupByField}
+    GROUP BY location
     HAVING location != ''
     ORDER BY visits DESC
-    LIMIT 10
+    LIMIT 20
   `;
   
   return executeQuery<GeoData>(query);
@@ -239,6 +252,9 @@ export async function getDeviceAnalytics(params: {
   startTime?: string;
   endTime?: string;
   linkId?: string;
+  teamIds?: string[];
+  projectIds?: string[];
+  tagIds?: string[];
 }): Promise<DeviceAnalytics> {
   const filter = buildFilter(params);