Add some public stats!

Author: confusinguser

app/src/api/routes.rs

@@ -1,13 +1,14 @@
-use crate::api::types::EventResponse;
+use crate::api::types::{CalendarStatsResponse, EventResponse};
 use crate::db::{Calendar, DbState};
 use crate::processing::rule::Rule;
 use crate::upstream;
+use axum::Json;
 use axum::body::Body;
 use axum::extract::{Path, State};
-use axum::http::{header, HeaderMap, StatusCode};
+use axum::http::{HeaderMap, StatusCode, header};
 use axum::response::IntoResponse;
-use axum::Json;
 use serde::{Deserialize, Serialize};
+use std::time::UNIX_EPOCH;
 use tokio_util::io::ReaderStream;
 use utoipa::ToSchema;
 use utoipa_axum::router::OpenApiRouter;
@@ -32,6 +33,7 @@ pub(crate) fn router() -> axum::Router<DbState> {
         .routes(routes!(allowlist_add))
         .routes(routes!(allowlist_remove))
         .routes(routes!(allowlist_list))
+        .routes(routes!(get_stats))
         .split_for_parts();
     app_router
         .route("/calendars/{id}/feed", axum::routing::get(get_feed))
@@ -99,7 +101,7 @@ pub async fn get_events(
     State(db): State<DbState>,
     Path(id): Path<String>,
 ) -> Result<Json<Vec<EventResponse>>, StatusCode> {
-    let db_lock = db.lock().await;
+    let mut db_lock = db.lock().await;
     let cal = db_lock
         .get_calendar(&id)
         .await
@@ -234,13 +236,19 @@ pub async fn get_feed(
     State(db): State<DbState>,
     Path(id): Path<String>,
 ) -> Result<(HeaderMap, Body), StatusCode> {
-    let db_lock = db.lock().await;
-    let calendar = db_lock
+    let mut db_lock = db.lock().await;
+    let mut calendar = db_lock
         .get_calendar(&id)
         .await
         .ok_or(StatusCode::NOT_FOUND)?;
     drop(db_lock);
 
+    calendar.last_accessed = Some(
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?
+            .as_secs(),
+    );
     let ical = calendar.get_filtered_icalendar();
 
     let reader = std::io::Cursor::new(ical.to_string().into_bytes());
@@ -557,3 +565,41 @@ pub async fn allowlist_list(
 
     Ok(Json(set))
 }
+
+#[utoipa::path(
+    get,
+    path = "/stats",
+    responses(
+        (status = 200, description = "Retrieved calendar statistics", body = CalendarStatsResponse),
+    )
+)]
+pub async fn get_stats(
+    State(db): State<DbState>,
+) -> Result<Json<CalendarStatsResponse>, StatusCode> {
+    let db_lock = db.lock().await;
+    let mut active_calendars = 0;
+    let calendars = db_lock.list_calendars().await;
+
+    for calendar in calendars {
+        let Some(last_accessed) = calendar.last_accessed else {
+            continue;
+        };
+        let Ok(duration_since_last_access) = std::time::SystemTime::now()
+            .duration_since(UNIX_EPOCH + std::time::Duration::from_secs(last_accessed))
+            .map_err(|err| {
+                eprintln!("Error calculating duration since last access: {}", err);
+                ()
+            })
+        else {
+            continue;
+        };
+
+        if duration_since_last_access < std::time::Duration::from_secs(2 * 24 * 60 * 60) {
+            active_calendars += 1;
+        }
+    }
+
+    let stats = CalendarStatsResponse { active_calendars };
+
+    Ok(Json(stats))
+}

app/src/api/types.rs

@@ -15,3 +15,8 @@ pub struct EventResponse {
     /// Whether this event is allowlisted (immune from rule blocking)
     pub manually_allowlisted: bool,
 }
+
+#[derive(Serialize, ToSchema)]
+pub struct CalendarStatsResponse {
+    pub(crate) active_calendars: i32,
+}

app/src/db.rs

@@ -81,6 +81,10 @@ impl Db {
         });
     }
 
+    pub async fn list_calendars(&self) -> Vec<Calendar> {
+        self.calendars.values().cloned().collect()
+    }
+
     pub async fn add_calendar(&mut self, mut calendar: Calendar) -> String {
         let id = calendar.id.clone();
         // We don't want to store all events in the DB, just the calendar metadata
@@ -90,12 +94,23 @@ impl Db {
         id
     }
 
-    pub async fn get_calendar(&self, id: &str) -> Option<Calendar> {
+    pub async fn get_calendar(&mut self, id: &str) -> Option<Calendar> {
         let calendars = self.calendars.get(id);
         let Some(mut calendar) = calendars.cloned() else {
             return None;
         };
 
+        // Update last accessed time
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+
+        if let Some(calendar_ref) = self.calendars.get_mut(id) {
+            calendar_ref.last_accessed = Some(now);
+            self.save_data_bg().await;
+        }
+
         // Check if we have cached events that are not expired
         let mut event_cache = EVENT_CACHE.lock().await;
         let cache = event_cache.get_mut(id);
@@ -287,6 +302,49 @@ impl Db {
         self.save_data_bg().await; // Auto-save
         Ok(())
     }
+
+    pub async fn cleanup_old_calendars(&mut self) -> Vec<String> {
+        let now = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_secs();
+
+        // One week in seconds = 7 days * 24 hours * 60 minutes * 60 seconds
+        let one_week_in_seconds = 7 * 24 * 60 * 60;
+        let cutoff_time = now - one_week_in_seconds;
+
+        let mut removed_ids = Vec::new();
+
+        // Identify calendars to remove (older than one week)
+        let to_remove: Vec<String> = self
+            .calendars
+            .iter()
+            .filter(|(_, calendar)| {
+                match calendar.last_accessed {
+                    Some(last_accessed) => last_accessed < cutoff_time,
+                    None => true, // Remove calendars with no access timestamp
+                }
+            })
+            .map(|(id, _)| id.clone())
+            .collect();
+
+        // Remove identified calendars
+        for id in &to_remove {
+            self.calendars.remove(id);
+
+            // Also clean up the event cache for this calendar
+            let mut event_cache = EVENT_CACHE.lock().await;
+            event_cache.remove(id);
+
+            removed_ids.push(id.clone());
+        }
+
+        if !removed_ids.is_empty() {
+            self.save_data_bg().await;
+        }
+
+        removed_ids
+    }
 }
 
 // Database instance type

app/src/main.rs

@@ -1,5 +1,8 @@
 use crate::api::routes;
 use std::net::SocketAddr;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::sync::Mutex;
 use tower_http::cors::{Any, CorsLayer};
 
 mod api;
@@ -17,6 +20,9 @@ async fn main() -> std::io::Result<()> {
     // Create shared database instance
     let db_state = db::create_db_instance(db_path).await;
 
+    // Start background task to clean up old calendars
+    start_calendar_cleanup_task(Arc::clone(&db_state));
+
     let socket_address: SocketAddr = "0.0.0.0:8000".parse().unwrap();
     let listener = tokio::net::TcpListener::bind(socket_address).await?;
 
@@ -38,11 +44,23 @@ async fn main() -> std::io::Result<()> {
 
     println!("Calendar Curator backend starting on {}", socket_address);
     axum::serve(listener, app.into_make_service()).await
+}
+
+fn start_calendar_cleanup_task(db_state: Arc<Mutex<db::Db>>) {
+    tokio::spawn(async move {
+        loop {
+            tokio::time::sleep(Duration::from_secs(30 * 60 * 60)).await;
+
+            // Clean up calendars that haven't been accessed in a week
+            let mut db = db_state.lock().await;
+            let removed_ids = db.cleanup_old_calendars().await;
 
-    // let str = get_calendar(Url::parse("https://cloud.timeedit.net/lu/web/lth1/ri6X80g51560Y2QQ95Z59X0Y0Yy5002495967Q564f596Z53X04Y55545761924X5595951539X54444399XQ55X554X676349yZoXy1u6beZnQQ90Z.ics")?).await;
-    // match str {
-    //     Ok(calendar) => println!("{}", calendar.to_string()),
-    //     Err(e) => eprintln!("Error fetching calendar: {}", e),
-    // };
-    // Ok(())
+            if !removed_ids.is_empty() {
+                println!(
+                    "Cleaned up {} calendars that haven't been accessed in a week",
+                    removed_ids.len()
+                );
+            }
+        }
+    });
 }

app/src/processing/calendar.rs

@@ -18,6 +18,7 @@ pub struct Calendar {
     pub manually_blocked: HashSet<String>,
     /// List of manually allowlisted event IDs (immune from rule blocking).
     pub manually_allowlisted: HashSet<String>,
+    pub last_accessed: Option<u64>,
 }
 
 impl Calendar {
@@ -29,6 +30,7 @@ impl Calendar {
             url,
             manually_blocked: HashSet::new(),
             manually_allowlisted: HashSet::new(),
+            last_accessed: None,
         }
     }
 
@@ -64,10 +66,6 @@ impl Calendar {
             .collect()
     }
 
-    pub fn get_events(self) -> Vec<Event> {
-        self.ical.events
-    }
-
     pub fn get_filtered_icalendar(&self) -> ICalendar {
         // To prevent cloning the events
         ICalendar {

web/app/layout.tsx

@@ -1,17 +1,6 @@
 import type { Metadata } from "next";
-import { Geist, Geist_Mono } from "next/font/google";
 import "./globals.css";
 
-const geistSans = Geist({
-  variable: "--font-geist-sans",
-  subsets: ["latin"],
-});
-
-const geistMono = Geist_Mono({
-  variable: "--font-geist-mono",
-  subsets: ["latin"],
-});
-
 export const metadata: Metadata = {
   title: "Calendar Curator",
   description: "Curate your calendar events with custom rules",
@@ -24,11 +13,7 @@ export default function RootLayout({
 }>) {
   return (
     <html lang="en">
-      <body
-        className={`${geistSans.variable} ${geistMono.variable} antialiased`}
-      >
-        {children}
-      </body>
+      <body className="antialiased">{children}</body>
     </html>
   );
 }

web/app/page.tsx

@@ -2,7 +2,13 @@
 
 import { Home } from "@/components/home";
 import React from "react";
+import { QueryClientProvider } from "@tanstack/react-query";
+import { QueryClient } from "@tanstack/query-core";
 
 export default function Page() {
-  return <Home />;
+  return (
+    <QueryClientProvider client={new QueryClient()}>
+      <Home />
+    </QueryClientProvider>
+  );
 }

web/components/blocked-events-panel.tsx

@@ -3,12 +3,7 @@
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { Button } from "@/components/ui/button";
 import { Badge } from "@/components/ui/badge";
-import {
-  EyeIcon,
-  EyeOffIcon, MapPinIcon,
-  ShieldCheckIcon,
-  ShieldXIcon,
-} from "lucide-react";
+import { EyeIcon, EyeOffIcon, MapPinIcon, ShieldCheckIcon, ShieldXIcon, } from "lucide-react";
 import { CalendarEvent } from "@/lib/api";
 import { getCalendarSettings } from "@/lib/settings";
 
@@ -129,7 +124,7 @@ export function BlockedEventsPanel({
 
                 {event.original.location && (
                   <div className="text-xs text-muted-foreground">
-                    <MapPinIcon/>
+                    <MapPinIcon />
                     {event.original.location}
                   </div>
                 )}

web/components/header.tsx

@@ -0,0 +1,52 @@
+import { CalendarIcon } from "lucide-react";
+import { useEffect, useState } from "react";
+import { $api } from "@/lib/api";
+
+export function Header() {
+  const [recentCalendars, setActiveCalendars] = useState<number | null>(null);
+
+  let { data: stats } = $api.useQuery("get", "/stats", {
+    refetchInterval: 5 * 60 * 1000, // Refetch every 5 minutes
+  });
+
+  useEffect(() => {
+    if (stats) {
+      setActiveCalendars(stats.active_calendars);
+    }
+  }, [stats]);
+
+  if (recentCalendars === null) {
+    return null;
+  }
+
+  return (
+    <>
+      <div className="text-center space-y-2">
+        <h1 className="text-4xl font-bold flex items-center justify-center gap-2 ">
+          <div className="gap-2 flex items-center justify-center bg-gradient-to-r from-blue-600 via-indigo-600 to-purple-600 bg-clip-text text-transparent">
+            <CalendarIcon className="h-8 w-8 text-blue-600" />
+            Calendar Curator
+          </div>
+        </h1>
+        {recentCalendars && (
+          <p className="text-slate-600">
+            Currently helping{" "}
+            <b>
+              {recentCalendars} {recentCalendars === 1 ? "person" : "people"}
+            </b>{" "}
+            manage their calendars
+          </p>
+        )}
+      </div>
+      <p className="absolute left-[90%] top-4 text-sm text-slate-500">
+        Made with ❤️ by{" "}
+        <a
+          href="https://github.com/confusinguser/calendar-curator"
+          className="text-blue-500 hover:underline"
+        >
+          Mostafa Kerim
+        </a>
+      </p>
+    </>
+  );
+}