feat: Implement uptime monitoring data retention

Ensured data is cleared from uptime_data and ping_data collections based on retention settings. Added separate manual shrink database buttons for uptime and server monitoring retention in the data retention settings panel.

application/src/components/dashboard/Sidebar.tsx

@@ -117,10 +117,10 @@ export const Sidebar = ({
                       <BookOpen className="h-4 w-4 mr-2" />
                       <span className="text-sm">{t("alertsTemplates")}</span>
                     </Link>
-                    <div className={getMenuItemClasses(false)}>
+                    <Link to={`/settings?panel=data-retention`} className={getMenuItemClasses(activeSettingsItem === 'data-retention')} onClick={() => handleSettingsItemClick('data-retention')}>
                       <Database className="h-4 w-4 mr-2" />
                       <span className="text-sm">{t("dataRetention")}</span>
-                    </div>
+                    </Link>
                     <Link to={`/settings?panel=about`} className={getMenuItemClasses(activeSettingsItem === 'about')} onClick={() => handleSettingsItemClick('about')}>
                       <Info className="h-4 w-4 mr-2" />
                       <span className="text-sm">{t("aboutSystem")}</span>

application/src/components/settings/data-retention/DataRetentionSettings.tsx

@@ -0,0 +1,316 @@
+
+import React, { useState, useEffect } from 'react';
+import { Button } from "@/components/ui/button";
+import { Card, CardContent, CardDescription, CardFooter, CardHeader, CardTitle } from "@/components/ui/card";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Alert, AlertDescription } from "@/components/ui/alert";
+import { Loader2, Database, Trash2, AlertTriangle, Globe, Server } from "lucide-react";
+import { useToast } from "@/hooks/use-toast";
+import { useLanguage } from "@/contexts/LanguageContext";
+import { authService } from "@/services/authService";
+import { dataRetentionService } from "@/services/dataRetentionService";
+
+interface RetentionSettings {
+  uptimeRetentionDays: number;
+  serverRetentionDays: number;
+}
+
+const DataRetentionSettings = () => {
+  const { t } = useLanguage();
+  const { toast } = useToast();
+  const [settings, setSettings] = useState<RetentionSettings>({
+    uptimeRetentionDays: 30,
+    serverRetentionDays: 30
+  });
+  const [isLoading, setIsLoading] = useState(true);
+  const [isSaving, setIsSaving] = useState(false);
+  const [isUptimeShrinking, setIsUptimeShrinking] = useState(false);
+  const [isServerShrinking, setIsServerShrinking] = useState(false);
+  const [isFullShrinking, setIsFullShrinking] = useState(false);
+  const [lastCleanup, setLastCleanup] = useState<string | null>(null);
+
+  // Check if user is super admin
+  const currentUser = authService.getCurrentUser();
+  const isSuperAdmin = currentUser?.role === "superadmin";
+
+  useEffect(() => {
+    if (isSuperAdmin) {
+      loadSettings();
+    }
+  }, [isSuperAdmin]);
+
+  const loadSettings = async () => {
+    try {
+      setIsLoading(true);
+      const result = await dataRetentionService.getRetentionSettings();
+      if (result) {
+        setSettings({
+          uptimeRetentionDays: result.uptimeRetentionDays || 30,
+          serverRetentionDays: result.serverRetentionDays || 30
+        });
+        setLastCleanup(result.lastCleanup);
+      }
+    } catch (error) {
+      console.error("Error loading retention settings:", error);
+      toast({
+        title: "Error",
+        description: "Failed to load retention settings",
+        variant: "destructive",
+      });
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleSave = async () => {
+    try {
+      setIsSaving(true);
+      await dataRetentionService.updateRetentionSettings(settings);
+      toast({
+        title: "Settings saved",
+        description: "Data retention settings have been updated",
+      });
+    } catch (error) {
+      console.error("Error saving retention settings:", error);
+      toast({
+        title: "Error",
+        description: "Failed to save retention settings",
+        variant: "destructive",
+      });
+    } finally {
+      setIsSaving(false);
+    }
+  };
+
+  const handleUptimeShrink = async () => {
+    try {
+      setIsUptimeShrinking(true);
+      const result = await dataRetentionService.manualUptimeCleanup();
+      
+      toast({
+        title: "Uptime cleanup completed",
+        description: `Deleted ${result.deletedRecords} old uptime records`,
+      });
+      
+      // Reload settings to get updated last cleanup time
+      await loadSettings();
+    } catch (error) {
+      console.error("Error during uptime cleanup:", error);
+      toast({
+        title: "Error",
+        description: "Failed to perform uptime data cleanup",
+        variant: "destructive",
+      });
+    } finally {
+      setIsUptimeShrinking(false);
+    }
+  };
+
+  const handleServerShrink = async () => {
+    try {
+      setIsServerShrinking(true);
+      const result = await dataRetentionService.manualServerCleanup();
+      
+      toast({
+        title: "Server cleanup completed",
+        description: `Deleted ${result.deletedRecords} old server records`,
+      });
+      
+      // Reload settings to get updated last cleanup time
+      await loadSettings();
+    } catch (error) {
+      console.error("Error during server cleanup:", error);
+      toast({
+        title: "Error",
+        description: "Failed to perform server data cleanup",
+        variant: "destructive",
+      });
+    } finally {
+      setIsServerShrinking(false);
+    }
+  };
+
+  const handleFullShrink = async () => {
+    try {
+      setIsFullShrinking(true);
+      const result = await dataRetentionService.manualCleanup();
+      
+      toast({
+        title: "Database cleanup completed",
+        description: `Deleted ${result.deletedRecords} old records`,
+      });
+      
+      // Reload settings to get updated last cleanup time
+      await loadSettings();
+    } catch (error) {
+      console.error("Error during manual cleanup:", error);
+      toast({
+        title: "Error",
+        description: "Failed to perform database cleanup",
+        variant: "destructive",
+      });
+    } finally {
+      setIsFullShrinking(false);
+    }
+  };
+
+  // Show permission notice for admin users
+  if (!isSuperAdmin) {
+    return (
+      <div className="p-4">
+        <Card>
+          <CardHeader>
+            <CardTitle className="flex items-center gap-2">
+              <Database className="h-5 w-5" />
+              {t("dataRetention", "settings")}
+            </CardTitle>
+          </CardHeader>
+          <CardContent className="space-y-4">
+            <Alert className="border-blue-200 bg-blue-50 dark:bg-blue-950 dark:border-blue-800">
+              <AlertTriangle className="h-5 w-5 text-blue-600 dark:text-blue-400" />
+              <AlertDescription className="text-blue-700 dark:text-blue-300">
+                <span className="font-medium">Permission Notice:</span> As an admin user, you do not have access to data retention settings. These settings can only be accessed and modified by Super Admins.
+              </AlertDescription>
+            </Alert>
+          </CardContent>
+        </Card>
+      </div>
+    );
+  }
+
+  if (isLoading) {
+    return (
+      <div className="p-4 flex items-center justify-center">
+        <Loader2 className="h-6 w-6 animate-spin mr-2" />
+        Loading retention settings...
+      </div>
+    );
+  }
+
+  return (
+    <div className="p-4 space-y-6">
+      <Card>
+        <CardHeader>
+          <CardTitle className="flex items-center gap-2">
+            <Database className="h-5 w-5" />
+            Data Retention Settings
+          </CardTitle>
+          <CardDescription>
+            Configure how long monitoring data is kept in the system
+          </CardDescription>
+        </CardHeader>
+        <CardContent className="space-y-6">
+          <div className="space-y-4">
+            <div>
+              <Label htmlFor="uptimeRetention">Uptime Monitoring Retention (days)</Label>
+              <Input
+                id="uptimeRetention"
+                type="number"
+                min="1"
+                max="365"
+                value={settings.uptimeRetentionDays}
+                onChange={(e) => setSettings(prev => ({
+                  ...prev,
+                  uptimeRetentionDays: parseInt(e.target.value) || 30
+                }))}
+                className="mt-1"
+              />
+              <p className="text-sm text-muted-foreground mt-1">
+                Service uptime and incident data older than this will be automatically deleted
+              </p>
+            </div>
+
+            <div>
+              <Label htmlFor="serverRetention">Server Monitoring Retention (days)</Label>
+              <Input
+                id="serverRetention"
+                type="number"
+                min="1"
+                max="365"
+                value={settings.serverRetentionDays}
+                onChange={(e) => setSettings(prev => ({
+                  ...prev,
+                  serverRetentionDays: parseInt(e.target.value) || 30
+                }))}
+                className="mt-1"
+              />
+              <p className="text-sm text-muted-foreground mt-1">
+                Server metrics and process data older than this will be automatically deleted
+              </p>
+            </div>
+          </div>
+
+          {lastCleanup && (
+            <Alert>
+              <Database className="h-4 w-4" />
+              <AlertDescription>
+                Last automatic cleanup: {new Date(lastCleanup).toLocaleString()}
+              </AlertDescription>
+            </Alert>
+          )}
+        </CardContent>
+        <CardFooter className="flex flex-col gap-4">
+          <div className="flex flex-wrap gap-2 w-full">
+            <Button
+              variant="outline"
+              onClick={handleUptimeShrink}
+              disabled={isUptimeShrinking}
+              className="flex items-center gap-2"
+            >
+              {isUptimeShrinking ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <Globe className="h-4 w-4" />
+              )}
+              Shrink Uptime Data
+            </Button>
+            
+            <Button
+              variant="outline"
+              onClick={handleServerShrink}
+              disabled={isServerShrinking}
+              className="flex items-center gap-2"
+            >
+              {isServerShrinking ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <Server className="h-4 w-4" />
+              )}
+              Shrink Server Data
+            </Button>
+            
+            <Button
+              variant="outline"
+              onClick={handleFullShrink}
+              disabled={isFullShrinking}
+              className="flex items-center gap-2"
+            >
+              {isFullShrinking ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <Trash2 className="h-4 w-4" />
+              )}
+              Full Database Shrink
+            </Button>
+          </div>
+          
+          <div className="flex justify-end w-full">
+            <Button
+              onClick={handleSave}
+              disabled={isSaving}
+              className="flex items-center gap-2"
+            >
+              {isSaving ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : null}
+              Save Changes
+            </Button>
+          </div>
+        </CardFooter>
+      </Card>
+    </div>
+  );
+};
+
+export default DataRetentionSettings;

application/src/components/settings/data-retention/index.ts

@@ -0,0 +1,5 @@
+
+import DataRetentionSettings from './DataRetentionSettings';
+
+export default DataRetentionSettings;
+export { DataRetentionSettings };

application/src/pages/Settings.tsx

@@ -9,6 +9,7 @@ import UserManagement from "@/components/settings/user-management";
 import { NotificationSettings } from "@/components/settings/notification-settings";
 import { AlertsTemplates } from "@/components/settings/alerts-templates";
 import { AboutSystem } from "@/components/settings/about-system";
+import DataRetentionSettings from "@/components/settings/data-retention/DataRetentionSettings";
 
 const Settings = () => {
   // State for sidebar collapse functionality
@@ -58,6 +59,7 @@ const Settings = () => {
           {activePanel === "users" && <UserManagement />}
           {activePanel === "notifications" && <NotificationSettings />}
           {activePanel === "templates" && <AlertsTemplates />}
+          {activePanel === "data-retention" && <DataRetentionSettings />}
           {activePanel === "about" && <AboutSystem />}
         </div>
       </div>
@@ -65,4 +67,4 @@ const Settings = () => {
   );
 };
 
-export default Settings;
+export default Settings;

application/src/services/dataRetentionService.ts

@@ -0,0 +1,293 @@
+
+import { pb } from '@/lib/pocketbase';
+
+interface RetentionSettings {
+  uptimeRetentionDays: number;
+  serverRetentionDays: number;
+  lastCleanup?: string;
+}
+
+interface CleanupResult {
+  deletedRecords: number;
+  collections: string[];
+}
+
+export const dataRetentionService = {
+  async getRetentionSettings(): Promise<RetentionSettings | null> {
+    try {
+      // Try to get existing settings from data_settings collection
+      const records = await pb.collection('data_settings').getFullList({
+        sort: '-created'
+      });
+      
+      if (records.length > 0) {
+        const settings = records[0];
+        return {
+          uptimeRetentionDays: settings.uptime_retention_days || 30,
+          serverRetentionDays: settings.server_retention_days || 30,
+          lastCleanup: settings.last_cleanup
+        };
+      }
+      
+      // Return default settings if none exist
+      return {
+        uptimeRetentionDays: 30,
+        serverRetentionDays: 30
+      };
+    } catch (error) {
+      console.error("Error fetching retention settings:", error);
+      // Return default settings on error
+      return {
+        uptimeRetentionDays: 30,
+        serverRetentionDays: 30
+      };
+    }
+  },
+
+  async updateRetentionSettings(settings: RetentionSettings): Promise<void> {
+    try {
+      // Check if settings already exist
+      const existingRecords = await pb.collection('data_settings').getFullList({
+        sort: '-created'
+      });
+      
+      const data = {
+        uptime_retention_days: settings.uptimeRetentionDays,
+        server_retention_days: settings.serverRetentionDays,
+        retention_days: Math.max(settings.uptimeRetentionDays, settings.serverRetentionDays), // General retention days
+        backup: "auto", // Default backup setting
+        updated: new Date().toISOString()
+      };
+      
+      if (existingRecords.length > 0) {
+        // Update existing record
+        await pb.collection('data_settings').update(existingRecords[0].id, data);
+      } else {
+        // Create new record
+        await pb.collection('data_settings').create({
+          ...data,
+          created: new Date().toISOString()
+        });
+      }
+      
+      console.log("Retention settings updated successfully");
+    } catch (error) {
+      console.error("Error updating retention settings:", error);
+      throw new Error("Failed to update retention settings");
+    }
+  },
+
+  async manualUptimeCleanup(): Promise<CleanupResult> {
+    try {
+      const settings = await this.getRetentionSettings();
+      if (!settings) {
+        throw new Error("Could not load retention settings");
+      }
+
+      let totalDeleted = 0;
+      const cleanedCollections: string[] = [];
+
+      // Calculate cutoff date for uptime data
+      const uptimeCutoffDate = new Date();
+      uptimeCutoffDate.setDate(uptimeCutoffDate.getDate() - settings.uptimeRetentionDays);
+
+      console.log(`Starting uptime cleanup - Cutoff: ${uptimeCutoffDate.toISOString()}`);
+
+      // Clean uptime_data collection
+      try {
+        const uptimeRecords = await pb.collection('uptime_data').getFullList({
+          filter: `created < "${uptimeCutoffDate.toISOString()}"`
+        });
+        
+        console.log(`Found ${uptimeRecords.length} uptime records to delete`);
+        
+        for (const record of uptimeRecords) {
+          await pb.collection('uptime_data').delete(record.id);
+          totalDeleted++;
+        }
+        
+        if (uptimeRecords.length > 0) {
+          cleanedCollections.push('uptime_data');
+        }
+      } catch (error) {
+        console.error("Error cleaning uptime_data:", error);
+      }
+
+      console.log(`Uptime cleanup completed. Deleted ${totalDeleted} records`);
+
+      return {
+        deletedRecords: totalDeleted,
+        collections: cleanedCollections
+      };
+    } catch (error) {
+      console.error("Error during uptime cleanup:", error);
+      throw new Error("Failed to perform uptime data cleanup");
+    }
+  },
+
+  async manualServerCleanup(): Promise<CleanupResult> {
+    try {
+      const settings = await this.getRetentionSettings();
+      if (!settings) {
+        throw new Error("Could not load retention settings");
+      }
+
+      let totalDeleted = 0;
+      const cleanedCollections: string[] = [];
+
+      // Calculate cutoff date for server data
+      const serverCutoffDate = new Date();
+      serverCutoffDate.setDate(serverCutoffDate.getDate() - settings.serverRetentionDays);
+
+      console.log(`Starting server cleanup - Cutoff: ${serverCutoffDate.toISOString()}`);
+
+      // Clean ping_data collection
+      try {
+        const pingRecords = await pb.collection('ping_data').getFullList({
+          filter: `created < "${serverCutoffDate.toISOString()}"`
+        });
+        
+        console.log(`Found ${pingRecords.length} ping records to delete`);
+        
+        for (const record of pingRecords) {
+          await pb.collection('ping_data').delete(record.id);
+          totalDeleted++;
+        }
+        
+        if (pingRecords.length > 0) {
+          cleanedCollections.push('ping_data');
+        }
+      } catch (error) {
+        console.error("Error cleaning ping_data:", error);
+      }
+
+      console.log(`Server cleanup completed. Deleted ${totalDeleted} records`);
+
+      return {
+        deletedRecords: totalDeleted,
+        collections: cleanedCollections
+      };
+    } catch (error) {
+      console.error("Error during server cleanup:", error);
+      throw new Error("Failed to perform server data cleanup");
+    }
+  },
+
+  async manualCleanup(): Promise<CleanupResult> {
+    try {
+      // Get current retention settings
+      const settings = await this.getRetentionSettings();
+      if (!settings) {
+        throw new Error("Could not load retention settings");
+      }
+
+      let totalDeleted = 0;
+      const cleanedCollections: string[] = [];
+
+      // Calculate cutoff dates
+      const uptimeCutoffDate = new Date();
+      uptimeCutoffDate.setDate(uptimeCutoffDate.getDate() - settings.uptimeRetentionDays);
+      
+      const serverCutoffDate = new Date();
+      serverCutoffDate.setDate(serverCutoffDate.getDate() - settings.serverRetentionDays);
+
+      console.log(`Starting manual cleanup - Uptime cutoff: ${uptimeCutoffDate.toISOString()}, Server cutoff: ${serverCutoffDate.toISOString()}`);
+
+      // Clean uptime_data collection
+      try {
+        const uptimeRecords = await pb.collection('uptime_data').getFullList({
+          filter: `created < "${uptimeCutoffDate.toISOString()}"`
+        });
+        
+        console.log(`Found ${uptimeRecords.length} uptime records to delete`);
+        
+        for (const record of uptimeRecords) {
+          await pb.collection('uptime_data').delete(record.id);
+          totalDeleted++;
+        }
+        
+        if (uptimeRecords.length > 0) {
+          cleanedCollections.push('uptime_data');
+        }
+      } catch (error) {
+        console.error("Error cleaning uptime_data:", error);
+      }
+
+      // Clean ping_data collection
+      try {
+        const pingRecords = await pb.collection('ping_data').getFullList({
+          filter: `created < "${serverCutoffDate.toISOString()}"`
+        });
+        
+        console.log(`Found ${pingRecords.length} ping records to delete`);
+        
+        for (const record of pingRecords) {
+          await pb.collection('ping_data').delete(record.id);
+          totalDeleted++;
+        }
+        
+        if (pingRecords.length > 0) {
+          cleanedCollections.push('ping_data');
+        }
+      } catch (error) {
+        console.error("Error cleaning ping_data:", error);
+      }
+
+      // Update last cleanup timestamp
+      await this.updateLastCleanupTime();
+
+      console.log(`Manual cleanup completed. Deleted ${totalDeleted} records from collections: ${cleanedCollections.join(', ')}`);
+
+      return {
+        deletedRecords: totalDeleted,
+        collections: cleanedCollections
+      };
+    } catch (error) {
+      console.error("Error during manual cleanup:", error);
+      throw new Error("Failed to perform database cleanup");
+    }
+  },
+
+  async updateLastCleanupTime(): Promise<void> {
+    try {
+      const existingRecords = await pb.collection('data_settings').getFullList({
+        sort: '-created'
+      });
+      
+      const data = {
+        last_cleanup: new Date().toISOString()
+      };
+      
+      if (existingRecords.length > 0) {
+        await pb.collection('data_settings').update(existingRecords[0].id, data);
+      }
+    } catch (error) {
+      console.error("Error updating last cleanup time:", error);
+    }
+  },
+
+  async scheduleAutomaticCleanup(): Promise<void> {
+    try {
+      const settings = await this.getRetentionSettings();
+      if (!settings) return;
+
+      // Check if enough time has passed since last cleanup (run daily)
+      if (settings.lastCleanup) {
+        const lastCleanup = new Date(settings.lastCleanup);
+        const now = new Date();
+        const hoursSinceLastCleanup = (now.getTime() - lastCleanup.getTime()) / (1000 * 60 * 60);
+        
+        if (hoursSinceLastCleanup < 24) {
+          console.log("Skipping automatic cleanup - last cleanup was less than 24 hours ago");
+          return;
+        }
+      }
+
+      console.log("Starting scheduled automatic cleanup");
+      const result = await this.manualCleanup();
+      console.log(`Automatic cleanup completed. Deleted ${result.deletedRecords} records`);
+    } catch (error) {
+      console.error("Error during automatic cleanup:", error);
+    }
+  }
+};