Ajout de la documentation pour les facettes

playbooks/facets.md

···
+# Comprehensive Implementation Plan: Faceted Filtering with Themed Pages
+
+## Goal
+Implement comprehensive faceted filtering on all fields from the community lexicon calendar event schema with performance optimization through caching, plus reusable themed pages with predefined filter configurations.
+
+## Data Structure Overview
+Filterable fields from the lexicon:
+- `name` (String) - Text search
+- `description` (String) - Text search  
+- `starts_at` / `ends_at` (DateTime) - Range filtering
+- `mode` (Enum: InPerson, Virtual, Hybrid) - Multi-select
+- `status` (Enum: Scheduled, Rescheduled, Cancelled, Postponed, Planned) - Multi-select
+- `locations` (Vec<EventLocation>) - Location-based filtering
+- `uris` (Vec<EventLink>) - URI type filtering
+- `extra` (HashMap) - Custom field filtering
+
+## Implementation Plan
+
+### Phase 1: Core Data Structures
+
+````rust
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Deserialize, Serialize, Clone, Default)]
+pub struct EventFilters {
+    // Text filters
+    pub name: Option<Vec<String>>,
+    pub description: Option<Vec<String>>,
+    
+    // Enum filters
+    pub status: Option<Vec<String>>,
+    pub mode: Option<Vec<String>>,
+    
+    // Date range filters
+    pub starts_after: Option<DateTime<Utc>>,
+    pub starts_before: Option<DateTime<Utc>>,
+    pub ends_after: Option<DateTime<Utc>>,
+    pub ends_before: Option<DateTime<Utc>>,
+    
+    // Location filters
+    pub location_type: Option<Vec<String>>,
+    pub location_name: Option<Vec<String>>,
+    
+    // URI/Link filters
+    pub uri_type: Option<Vec<String>>,
+    
+    // Extra field filters
+    pub extra_keys: Option<Vec<String>>,
+    pub extra_values: Option<HashMap<String, Vec<String>>>,
+    
+    // Existing filters
+    pub organizer_did: Option<String>,
+    pub sort_by: Option<String>,
+    pub page: Option<i64>,
+    pub page_size: Option<i64>,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ThemedPageConfig {
+    pub id: String,
+    pub title: String,
+    pub description: Option<String>,
+    pub base_filters: EventFilters,
+    pub template_name: Option<String>,
+    pub css_class: Option<String>,
+    pub enabled: bool,
+    pub seo_keywords: Option<Vec<String>>,
+    pub cache_ttl: Option<u64>, // Custom cache TTL for this theme
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct ThemedPagesConfig {
+    pub pages: Vec<ThemedPageConfig>,
+}
+
+impl EventFilters {
+    /// Merge user filters with theme base filters
+    /// Base filters act as constraints, user filters refine within those constraints
+    pub fn merge_with_base(mut self, base: &EventFilters) -> Self {
+        // Text filters: combine if both exist
+        if self.name.is_none() && base.name.is_some() {
+            self.name = base.name.clone();
+        } else if let (Some(user_names), Some(base_names)) = (&mut self.name, &base.name) {
+            user_names.extend(base_names.clone());
+        }
+        
+        if self.description.is_none() && base.description.is_some() {
+            self.description = base.description.clone();
+        } else if let (Some(user_desc), Some(base_desc)) = (&mut self.description, &base.description) {
+            user_desc.extend(base_desc.clone());
+        }
+        
+        // Enum filters: intersect to ensure user selection stays within theme constraints
+        self.status = self.intersect_string_filters(self.status, base.status.clone());
+        self.mode = self.intersect_string_filters(self.mode, base.mode.clone());
+        self.location_type = self.intersect_string_filters(self.location_type, base.location_type.clone());
+        self.location_name = self.intersect_string_filters(self.location_name, base.location_name.clone());
+        self.uri_type = self.intersect_string_filters(self.uri_type, base.uri_type.clone());
+        
+        // Date filters: use more restrictive range
+        if let Some(base_after) = base.starts_after {
+            self.starts_after = Some(match self.starts_after {
+                Some(user_after) => user_after.max(base_after),
+                None => base_after,
+            });
+        }
+        
+        if let Some(base_before) = base.starts_before {
+            self.starts_before = Some(match self.starts_before {
+                Some(user_before) => user_before.min(base_before),
+                None => base_before,
+            });
+        }
+        
+        // Extra fields: combine
+        if let Some(base_keys) = &base.extra_keys {
+            match &mut self.extra_keys {
+                Some(user_keys) => user_keys.extend(base_keys.clone()),
+                None => self.extra_keys = base.extra_keys.clone(),
+            }
+        }
+        
+        if let Some(base_values) = &base.extra_values {
+            match &mut self.extra_values {
+                Some(user_values) => {
+                    for (key, values) in base_values {
+                        user_values.entry(key.clone()).or_insert_with(Vec::new).extend(values.clone());
+                    }
+                }
+                None => self.extra_values = base.extra_values.clone(),
+            }
+        }
+        
+        // Use base values if user didn't specify
+        if self.organizer_did.is_none() {
+            self.organizer_did = base.organizer_did.clone();
+        }
+        if self.sort_by.is_none() {
+            self.sort_by = base.sort_by.clone();
+        }
+        
+        self
+    }
+    
+    fn intersect_string_filters(&self, user: Option<Vec<String>>, base: Option<Vec<String>>) -> Option<Vec<String>> {
+        match (user, base) {
+            (Some(user_vec), Some(base_vec)) => {
+                let intersection: Vec<String> = user_vec.into_iter()
+                    .filter(|item| base_vec.contains(item))
+                    .collect();
+                if intersection.is_empty() { Some(base_vec) } else { Some(intersection) }
+            }
+            (None, Some(base_vec)) => Some(base_vec),
+            (Some(user_vec), None) => Some(user_vec),
+            (None, None) => None,
+        }
+    }
+}
+````
+
+### Phase 2: Hydration and Caching Infrastructure
+
+````rust
+use crate::community_lexicon::{Event, EventLocation, EventLink, Mode, Status};
+use chrono::{DateTime, Utc};
+use redis::AsyncCommands;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use thiserror::Error;
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct HydratedEvent {
+    pub name: String,
+    pub description: String,
+    pub starts_at: Option<DateTime<Utc>>,
+    pub ends_at: Option<DateTime<Utc>>,
+    pub mode: Option<Mode>,
+    pub status: Option<Status>,
+    pub locations: Vec<EventLocation>,
+    pub uris: Vec<EventLink>,
+    pub extra: HashMap<String, serde_json::Value>,
+}
+
+#[derive(Debug, Error)]
+pub enum CacheError {
+    #[error("Redis error: {0}")]
+    Redis(#[from] redis::RedisError),
+    #[error("Serialization error: {0}")]
+    Serialization(#[from] serde_json::Error),
+    #[error("Connection pool error: {0}")]
+    ConnectionPool(#[from] deadpool::managed::PoolError),
+    #[error("AT Protocol error: {0}")]
+    AtProtocol(String),
+}
+
+pub struct EventHydrationCache {
+    redis_pool: deadpool_redis::Pool,
+    default_ttl: u64,
+}
+
+impl EventHydrationCache {
+    pub fn new(redis_pool: deadpool_redis::Pool, default_ttl: u64) -> Self {
+        Self { redis_pool, default_ttl }
+    }
+    
+    /// Get hydrated event from cache or fetch from AT Protocol
+    pub async fn get_hydrated_event(&self, aturi: &str, custom_ttl: Option<u64>) -> Result<HydratedEvent, CacheError> {
+        let cache_key = format!("event_hydrated:{}", aturi);
+        
+        // Try cache first
+        if let Some(cached) = self.get_from_cache(&cache_key).await? {
+            return Ok(cached);
+        }
+        
+        // Fetch from AT Protocol
+        let hydrated = self.hydrate_from_atproto(aturi).await?;
+        
+        // Store in cache
+        let ttl = custom_ttl.unwrap_or(self.default_ttl);
+        self.store_in_cache(&cache_key, &hydrated, ttl).await?;
+        
+        Ok(hydrated)
+    }
+    
+    /// Batch hydrate multiple events
+    pub async fn batch_hydrate_events(&self, aturis: &[String]) -> Result<HashMap<String, HydratedEvent>, CacheError> {
+        let mut results = HashMap::new();
+        let mut to_fetch = Vec::new();
+        
+        // Check cache for all events
+        for aturi in aturis {
+            let cache_key = format!("event_hydrated:{}", aturi);
+            if let Some(cached) = self.get_from_cache(&cache_key).await? {
+                results.insert(aturi.clone(), cached);
+            } else {
+                to_fetch.push(aturi.clone());
+            }
+        }
+        
+        // Fetch missing events from AT Protocol (in parallel)
+        let fetch_futures: Vec<_> = to_fetch.iter()
+            .map(|aturi| self.hydrate_from_atproto(aturi))
+            .collect();
+        
+        let fetch_results = futures::future::join_all(fetch_futures).await;
+        
+        // Store fetched results and add to return map
+        for (aturi, result) in to_fetch.iter().zip(fetch_results) {
+            match result {
+                Ok(hydrated) => {
+                    let cache_key = format!("event_hydrated:{}", aturi);
+                    let _ = self.store_in_cache(&cache_key, &hydrated, self.default_ttl).await;
+                    results.insert(aturi.clone(), hydrated);
+                }
+                Err(e) => log::warn!("Failed to hydrate event {}: {}", aturi, e),
+            }
+        }
+        
+        Ok(results)
+    }
+    
+    async fn get_from_cache(&self, cache_key: &str) -> Result<Option<HydratedEvent>, CacheError> {
+        let mut conn = self.redis_pool.get().await?;
+        let cached_data: Option<String> = conn.get(cache_key).await?;
+        
+        match cached_data {
+            Some(data) => {
+                let hydrated_event: HydratedEvent = serde_json::from_str(&data)?;
+                Ok(Some(hydrated_event))
+            }
+            None => Ok(None),
+        }
+    }
+    
+    async fn store_in_cache(&self, cache_key: &str, event: &HydratedEvent, ttl: u64) -> Result<(), CacheError> {
+        let mut conn = self.redis_pool.get().await?;
+        let data = serde_json::to_string(event)?;
+        conn.set(cache_key, data).await?;
+        conn.expire(cache_key, ttl as i64).await?;
+        Ok(())
+    }
+    
+    async fn hydrate_from_atproto(&self, aturi: &str) -> Result<HydratedEvent, CacheError> {
+        // Mock implementation - replace with actual AT Protocol client
+        let event_data = fetch_event_from_atproto(aturi).await
+            .map_err(|e| CacheError::AtProtocol(e.to_string()))?;
+        
+        match event_data {
+            Event::Current {
+                name, description, starts_at, ends_at, mode, status, locations, uris, extra
+            } => Ok(HydratedEvent {
+                name, description, starts_at, ends_at, mode, status, locations, uris, extra
+            })
+        }
+    }
+    
+    /// Invalidate cache for specific event
+    pub async fn invalidate_event(&self, aturi: &str) -> Result<(), CacheError> {
+        let cache_key = format!("event_hydrated:{}", aturi);
+        let mut conn = self.redis_pool.get().await?;
+        conn.del(&cache_key).await?;
+        Ok(())
+    }
+}
+
+// Mock function - implement with actual AT Protocol client
+async fn fetch_event_from_atproto(aturi: &str) -> Result<Event, anyhow::Error> {
+    // Implementation depends on your AT Protocol client
+    unimplemented!("Implement AT Protocol event fetching")
+}
+````
+
+### Phase 3: Filtering Engine
+
+````rust
+use crate::cache::event_hydration::{EventHydrationCache, HydratedEvent};
+use crate::http::filters::EventFilters;
+use crate::storage::{EventWithRole, StoragePool};
+use anyhow::Result;
+
+pub struct EventFilteringService {
+    hydration_cache: EventHydrationCache,
+}
+
+impl EventFilteringService {
+    pub fn new(hydration_cache: EventHydrationCache) -> Self {
+        Self { hydration_cache }
+    }
+    
+    /// Apply comprehensive filtering with caching
+    pub async fn filter_events(
+        &self,
+        storage_pool: &StoragePool,
+        filters: &EventFilters,
+    ) -> Result<(i64, Vec<EventWithRole>)> {
+        // Step 1: Database pre-filtering (for efficiently filterable fields)
+        let db_events = self.get_events_from_db(storage_pool, filters).await?;
+        
+        // Step 2: Extract AT-URIs for hydration
+        let aturis: Vec<String> = db_events.iter()
+            .map(|e| e.event.aturi.clone())
+            .collect();
+        
+        // Step 3: Batch hydrate events
+        let hydrated_map = self.hydration_cache.batch_hydrate_events(&aturis).await?;
+        
+        // Step 4: Apply comprehensive filters
+        let filtered_events = self.apply_comprehensive_filters(db_events, &hydrated_map, filters);
+        
+        // Step 5: Apply sorting and pagination
+        let sorted_events = self.apply_sorting_and_pagination(filtered_events, filters);
+        
+        let total_count = sorted_events.len() as i64;
+        Ok((total_count, sorted_events))
+    }
+    
+    async fn get_events_from_db(
+        &self,
+        pool: &StoragePool,
+        filters: &EventFilters,
+    ) -> Result<Vec<EventWithRole>> {
+        // Build database query with efficiently filterable fields only
+        // Organizer DID, date ranges, basic metadata
+        // Don't filter on fields that require AT Protocol data
+        
+        // Implementation would call your existing database query function
+        // but modified to exclude AT Protocol dependent filters
+        unimplemented!("Implement database pre-filtering")
+    }
+    
+    fn apply_comprehensive_filters(
+        &self,
+        events: Vec<EventWithRole>,
+        hydrated_map: &std::collections::HashMap<String, HydratedEvent>,
+        filters: &EventFilters,
+    ) -> Vec<EventWithRole> {
+        events.into_iter()
+            .filter(|event_with_role| {
+                if let Some(hydrated) = hydrated_map.get(&event_with_role.event.aturi) {
+                    self.should_include_event(hydrated, filters)
+                } else {
+                    // If hydration failed, include in results but log warning
+                    log::warn!("Failed to hydrate event: {}", event_with_role.event.aturi);
+                    true
+                }
+            })
+            .collect()
+    }
+    
+    fn should_include_event(&self, event: &HydratedEvent, filters: &EventFilters) -> bool {
+        // Text filters (case-insensitive partial matching)
+        if let Some(name_filters) = &filters.name {
+            if !name_filters.is_empty() {
+                let matches = name_filters.iter().any(|filter| {
+                    event.name.to_lowercase().contains(&filter.to_lowercase())
+                });
+                if !matches { return false; }
+            }
+        }
+        
+        if let Some(desc_filters) = &filters.description {
+            if !desc_filters.is_empty() {
+                let matches = desc_filters.iter().any(|filter| {
+                    event.description.to_lowercase().contains(&filter.to_lowercase())
+                });
+                if !matches { return false; }
+            }
+        }
+        
+        // Status enum filter
+        if let Some(status_filters) = &filters.status {
+            if !status_filters.is_empty() {
+                if let Some(event_status) = &event.status {
+                    let status_str = match event_status {
+                        Status::Scheduled => "scheduled",
+                        Status::Rescheduled => "rescheduled",
+                        Status::Cancelled => "cancelled",
+                        Status::Postponed => "postponed",
+                        Status::Planned => "planned",
+                    };
+                    if !status_filters.contains(&status_str.to_string()) {
+                        return false;
+                    }
+                } else {
+                    return false; // No status but filter requires one
+                }
+            }
+        }
+        
+        // Mode enum filter
+        if let Some(mode_filters) = &filters.mode {
+            if !mode_filters.is_empty() {
+                if let Some(event_mode) = &event.mode {
+                    let mode_str = match event_mode {
+                        Mode::InPerson => "inperson",
+                        Mode::Virtual => "virtual",
+                        Mode::Hybrid => "hybrid",
+                    };
+                    if !mode_filters.contains(&mode_str.to_string()) {
+                        return false;
+                    }
+                } else {
+                    return false; // No mode but filter requires one
+                }
+            }
+        }
+        
+        // Date range filters
+        if let Some(starts_after) = filters.starts_after {
+            if let Some(event_starts) = event.starts_at {
+                if event_starts <= starts_after {
+                    return false;
+                }
+            } else {
+                return false; // No start time but filter requires one
+            }
+        }
+        
+        if let Some(starts_before) = filters.starts_before {
+            if let Some(event_starts) = event.starts_at {
+                if event_starts >= starts_before {
+                    return false;
+                }
+            }
+        }
+        
+        if let Some(ends_after) = filters.ends_after {
+            if let Some(event_ends) = event.ends_at {
+                if event_ends <= ends_after {
+                    return false;
+                }
+            }
+        }
+        
+        if let Some(ends_before) = filters.ends_before {
+            if let Some(event_ends) = event.ends_at {
+                if event_ends >= ends_before {
+                    return false;
+                }
+            }
+        }
+        
+        // Location filters
+        if let Some(location_name_filters) = &filters.location_name {
+            if !location_name_filters.is_empty() {
+                let has_matching_location = event.locations.iter().any(|loc| {
+                    location_name_filters.iter().any(|filter| {
+                        loc.name.to_lowercase().contains(&filter.to_lowercase())
+                    })
+                });
+                if !has_matching_location {
+                    return false;
+                }
+            }
+        }
+        
+        if let Some(location_type_filters) = &filters.location_type {
+            if !location_type_filters.is_empty() {
+                let has_matching_type = event.locations.iter().any(|loc| {
+                    location_type_filters.iter().any(|filter| {
+                        // Match against location properties
+                        loc.name.to_lowercase().contains(&filter.to_lowercase())
+                    })
+                });
+                if !has_matching_type {
+                    return false;
+                }
+            }
+        }
+        
+        // URI filters
+        if let Some(uri_type_filters) = &filters.uri_type {
+            if !uri_type_filters.is_empty() {
+                let has_matching_uri = event.uris.iter().any(|uri| {
+                    uri_type_filters.iter().any(|filter| {
+                        uri.uri.to_lowercase().contains(&filter.to_lowercase())
+                    })
+                });
+                if !has_matching_uri {
+                    return false;
+                }
+            }
+        }
+        
+        // Extra fields filters
+        if let Some(extra_key_filters) = &filters.extra_keys {
+            if !extra_key_filters.is_empty() {
+                let has_matching_key = extra_key_filters.iter().any(|key| {
+                    event.extra.contains_key(key)
+                });
+                if !has_matching_key {
+                    return false;
+                }
+            }
+        }
+        
+        if let Some(extra_value_filters) = &filters.extra_values {
+            for (key, values) in extra_value_filters {
+                if let Some(event_value) = event.extra.get(key) {
+                    let event_value_str = event_value.to_string().to_lowercase();
+                    if !values.iter().any(|v| event_value_str.contains(&v.to_lowercase())) {
+                        return false;
+                    }
+                } else {
+                    return false; // Required key not present
+                }
+            }
+        }
+        
+        true
+    }
+    
+    fn apply_sorting_and_pagination(
+        &self,
+        mut events: Vec<EventWithRole>,
+        filters: &EventFilters,
+    ) -> Vec<EventWithRole> {
+        // Apply sorting
+        if let Some(sort_by) = &filters.sort_by {
+            match sort_by.as_str() {
+                "starts_at" => {
+                    events.sort_by(|a, b| {
+                        // Would need to access hydrated data for sorting
+                        // For now, use database field if available
+                        std::cmp::Ordering::Equal
+                    });
+                }
+                "name" => {
+                    events.sort_by(|a, b| {
+                        // Similar challenge - would need hydrated data
+                        std::cmp::Ordering::Equal
+                    });
+                }
+                _ => {} // Default order
+            }
+        }
+        
+        // Apply pagination
+        let page = filters.page.unwrap_or(1);
+        let page_size = filters.page_size.unwrap_or(20);
+        let start_idx = ((page - 1) * page_size) as usize;
+        let end_idx = (start_idx + page_size as usize).min(events.len());
+        
+        if start_idx < events.len() {
+            events[start_idx..end_idx].to_vec()
+        } else {
+            Vec::new()
+        }
+    }
+}
+````
+
+### Phase 4: Themed Pages Configuration
+
+````rust
+use crate::http::filters::{EventFilters, ThemedPageConfig, ThemedPagesConfig};
+use chrono::{Duration, Utc};
+use std::collections::HashMap;
+
+impl Default for ThemedPagesConfig {
+    fn default() -> Self {
+        Self {
+            pages: vec![
+                // Virtual Events Theme
+                ThemedPageConfig {
+                    id: "virtual-events".to_string(),
+                    title: "Virtual Events".to_string(),
+                    description: Some("Online events you can attend from anywhere".to_string()),
+                    base_filters: EventFilters {
+                        mode: Some(vec!["virtual".to_string()]),
+                        status: Some(vec!["scheduled".to_string(), "planned".to_string()]),
+                        starts_after: Some(Utc::now()),
+                        sort_by: Some("starts_at".to_string()),
+                        ..Default::default()
+                    },
+                    template_name: Some("virtual_events".to_string()),
+                    css_class: Some("virtual-theme".to_string()),
+                    enabled: true,
+                    seo_keywords: Some(vec!["virtual".to_string(), "online".to_string(), "remote".to_string()]),
+                    cache_ttl: Some(1800), // 30 minutes for dynamic content
+                },
+                
+                // Local Meetups Theme
+                ThemedPageConfig {
+                    id: "local-meetups".to_string(),
+                    title: "Local Meetups".to_string(),
+                    description: Some("In-person community gatherings in your area".to_string()),
+                    base_filters: EventFilters {
+                        mode: Some(vec!["inperson".to_string()]),
+                        extra_keys: Some(vec!["meetup".to_string(), "community".to_string(), "local".to_string()]),
+                        status: Some(vec!["scheduled".to_string()]),
+                        starts_after: Some(Utc::now()),
+                        sort_by: Some("starts_at".to_string()),
+                        ..Default::default()
+                    },
+                    template_name: Some("local_meetups".to_string()),
+                    css_class: Some("meetup-theme".to_string()),
+                    enabled: true,
+                    seo_keywords: Some(vec!["meetup".to_string(), "local".to_string(), "community".to_string()]),
+                    cache_ttl: Some(3600), // 1 hour
+                },
+                
+                // Conferences Theme
+                ThemedPageConfig {
+                    id: "conferences".to_string(),
+                    title: "Conferences & Large Events".to_string(),
+                    description: Some("Major conferences, summits, and large-scale professional events".to_string()),
+                    base_filters: EventFilters {
+                        extra_keys: Some(vec!["conference".to_string(), "summit".to_string(), "convention".to_string()]),
+                        uri_type: Some(vec!["tickets".to_string(), "registration".to_string()]),
+                        status: Some(vec!["scheduled".to_string(), "planned".to_string()]),
+                        sort_by: Some("starts_at".to_string()),
+                        ..Default::default()
+                    },
+                    template_name: Some("conferences".to_string()),
+                    css_class: Some("conference-theme".to_string()),
+                    enabled: true,
+                    seo_keywords: Some(vec!["conference".to_string(), "summit".to_string(), "professional".to_string()]),
+                    cache_ttl: Some(7200), // 2 hours - conferences change less frequently
+                },
+                
+                // This Week Theme
+                ThemedPageConfig {
+                    id: "this-week".to_string(),
+                    title: "This Week's Events".to_string(),
+                    description: Some("All events happening in the next 7 days".to_string()),
+                    base_filters: EventFilters {
+                        starts_after: Some(Utc::now()),
+                        starts_before: Some(Utc::now() + Duration::days(7)),
+                        status: Some(vec!["scheduled".to_string()]),
+                        sort_by: Some("starts_at".to_string()),
+                        ..Default::default()
+                    },
+                    template_name: Some("this_week".to_string()),
+                    css_class: Some("this-week-theme".to_string()),
+                    enabled: true,
+                    seo_keywords: Some(vec!["this week".to_string(), "upcoming".to_string(), "soon".to_string()]),
+                    cache_ttl: Some(900), // 15 minutes - very dynamic content
+                },
+                
+                // Free Events Theme
+                ThemedPageConfig {
+                    id: "free-events".to_string(),
+                    title: "Free Events".to_string(),
+                    description: Some("No-cost events open to everyone".to_string()),
+                    base_filters: EventFilters {
+                        extra_values: Some(HashMap::from([
+                            ("cost".to_string(), vec!["free".to_string(), "0".to_string(), "$0".to_string()]),
+                            ("price".to_string(), vec!["free".to_string(), "0".to_string(), "$0".to_string()]),
+                            ("admission".to_string(), vec!["free".to_string(), "no cost".to_string()]),
+                        ])),
+                        status: Some(vec!["scheduled".to_string(), "planned".to_string()]),
+                        starts_after: Some(Utc::now()),
+                        sort_by: Some("starts_at".to_string()),
+                        ..Default::default()
+                    },
+                    template_name: Some("free_events".to_string()),
+                    css_class: Some("free-theme".to_string()),
+                    enabled: true,
+                    seo_keywords: Some(vec!["free".to_string(), "no cost".to_string(), "complimentary".to_string()]),
+                    cache_ttl: Some(3600), // 1 hour
+                },
+                
+                // Tech Events Theme
+                ThemedPageConfig {
+                    id: "tech-events".to_string(),
+                    title: "Tech Events".to_string(),
+                    description: Some("Technology, programming, and software development events".to_string()),
+                    base_filters: EventFilters {
+                        extra_keys: Some(vec![
+                            "tech".to_string(), "programming".to_string(), "software".to_string(),
+                            "development".to_string(), "coding".to_string(), "technology".to_string()
+                        ]),
+                        status: Some(vec!["scheduled".to_string(), "planned".to_string()]),
+                        sort_by: Some("starts_at".to_string()),
+                        ..Default::default()
+                    },
+                    template_name: Some("tech_events".to_string()),
+                    css_class: Some("tech-theme".to_string()),
+                    enabled: true,
+                    seo_keywords: Some(vec!["tech".to_string(), "programming".to_string(), "software".to_string()]),
+                    cache_ttl: Some(3600), // 1 hour
+                },
+            ],
+        }
+    }
+}
+
+pub fn load_themed_pages_config() -> ThemedPagesConfig {
+    // Try to load from config file, fall back to defaults
+    match std::fs::read_to_string("config/themed_pages.toml") {
+        Ok(content) => toml::from_str(&content).unwrap_or_else(|e| {
+            log::warn!("Failed to parse themed_pages.toml: {}. Using defaults.", e);
+            ThemedPagesConfig::default()
+        }),
+        Err(_) => {
+            log::info!("No themed_pages.toml found, using default configuration");
+            ThemedPagesConfig::default()
+        }
+    }
+}
+
+/// Validate themed page configuration
+pub fn validate_themed_config(config: &ThemedPagesConfig) -> Result<(), String> {
+    let mut seen_ids = std::collections::HashSet::new();
+    
+    for page in &config.pages {
+        // Check for duplicate IDs
+        if !seen_ids.insert(&page.id) {
+            return Err(format!("Duplicate theme ID: {}", page.id));
+        }
+        
+        // Validate ID format (alphanumeric and hyphens only)
+        if !page.id.chars().all(|c| c.is_alphanumeric() || c == '-') {
+            return Err(format!("Invalid theme ID format: {}. Use only alphanumeric characters and hyphens.", page.id));
+        }
+        
+        // Validate template name if specified
+        if let Some(template) = &page.template_name {
+            if template.is_empty() {
+                return Err(format!("Empty template name for theme: {}", page.id));
+            }
+        }
+        
+        // Validate cache TTL
+        if let Some(ttl) = page.cache_ttl {
+            if ttl == 0 {
+                return Err(format!("Cache TTL cannot be 0 for theme: {}", page.id));
+            }
+        }
+    }
+    
+    Ok(())
+}
+````
+
+### Phase 5: HTTP Handlers
+
+````rust
+use crate::config::themed_pages::{load_themed_pages_config, validate_themed_config};
+use crate::http::filters::EventFilters;
+use crate::services::event_filtering::EventFilteringService;
+use crate::AppState;
+use axum::{
+    extract::{Path, Query, State},
+    http::StatusCode,
+    response::Html,
+    Json,
+};
+use serde_json::json;
+
+/// List all available themed pages
+pub async fn handle_themed_pages_index(
+    State(app_state): State<AppState>,
+) -> Result<Html<String>, StatusCode> {
+    let themed_config = load_themed_pages_config();
+    
+    // Validate configuration
+    if let Err(e) = validate_themed_config(&themed_config) {
+        log::error!("Invalid themed pages configuration: {}", e);
+        return Err(StatusCode::INTERNAL_SERVER_ERROR);
+    }
+    
+    let enabled_themes: Vec<_> = themed_config.pages
+        .into_iter()
+        .filter(|p| p.enabled)
+        .collect();
+    
+    let context = json!({
+        "themes": enabled_themes,
+        "page_title": "Themed Event Pages",
+        "page_description": "Discover events organized by type and category",
+    });
+    
+    let html = app_state.templates.render("themed_pages_index", &context)
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    Ok(Html(html))
+}
+
+/// Handle themed events page with optional user refinement
+pub async fn handle_themed_events_page(
+    Path(theme_id): Path<String>,
+    Query(user_filters): Query<EventFilters>,
+    State(app_state): State<AppState>,
+) -> Result<Html<String>, StatusCode> {
+    let themed_config = load_themed_pages_config();
+    
+    // Find the requested theme
+    let theme = themed_config.pages
+        .iter()
+        .find(|p| p.id == theme_id && p.enabled)
+        .ok_or(StatusCode::NOT_FOUND)?;
+    
+    // Merge user filters with theme base filters
+    let final_filters = user_filters.merge_with_base(&theme.base_filters);
+    
+    // Apply filtering through service
+    let filtering_service = EventFilteringService::new(app_state.hydration_cache.clone());
+    let (total_count, events) = filtering_service
+        .filter_events(&app_state.storage_pool, &final_filters)
+        .await
+        .map_err(|e| {
+            log::error!("Failed to filter events for theme {}: {}", theme_id, e);
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+    
+    // Render with theme-specific template
+    let template_name = theme.template_name.as_deref().unwrap_or("events_themed");
+    let context = json!({
+        "events": events,
+        "total_count": total_count,
+        "theme": theme,
+        "current_filters": final_filters,
+        "page_title": theme.title,
+        "page_description": theme.description,
+        "css_class": theme.css_class,
+        "seo_keywords": theme.seo_keywords,
+        "theme_id": theme_id,
+    });
+    
+    let html = app_state.templates.render(template_name, &context)
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    Ok(Html(html))
+}
+
+/// Handle general events filtering (non-themed)
+pub async fn handle_events_filtered(
+    Query(filters): Query<EventFilters>,
+    State(app_state): State<AppState>,
+) -> Result<Html<String>, StatusCode> {
+    let filtering_service = EventFilteringService::new(app_state.hydration_cache.clone());
+    let (total_count, events) = filtering_service
+        .filter_events(&app_state.storage_pool, &filters)
+        .await
+        .map_err(|e| {
+            log::error!("Failed to filter events: {}", e);
+            StatusCode::INTERNAL_SERVER_ERROR
+        })?;
+    
+    let context = json!({
+        "events": events,
+        "total_count": total_count,
+        "current_filters": filters,
+        "page_title": "All Events",
+        "available_themes": load_themed_pages_config().pages.into_iter().filter(|p| p.enabled).collect::<Vec<_>>(),
+    });
+    
+    let html = app_state.templates.render("events_filtered", &context)
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+    Ok(Html(html))
+}
+
+/// API endpoint for theme configuration (for admin/debugging)
+pub async fn handle_themed_config_api() -> Result<Json<serde_json::Value>, StatusCode> {
+    let config = load_themed_pages_config();
+    
+    if let Err(e) = validate_themed_config(&config) {
+        return Ok(Json(json!({
+            "error": format!("Invalid configuration: {}", e),
+            "valid": false
+        })));
+    }
+    
+    Ok(Json(json!({
+        "config": config,
+        "valid": true,
+        "enabled_count": config.pages.iter().filter(|p| p.enabled).count()
+    })))
+}
+````
+
+### Phase 6: Templates
+
+````html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{page_title}}</title>
+    <meta name="description" content="{{page_description}}">
+    <link rel="stylesheet" href="/css/themes.css">
+</head>
+<body>
+    <div class="themed-pages-index">
+        <header>
+            <h1>{{page_title}}</h1>
+            <p class="subtitle">{{page_description}}</p>
+        </header>
+        
+        <div class="theme-grid">
+            {{#each themes}}
+            <div class="theme-card {{css_class}}" data-theme-id="{{id}}">
+                <h3><a href="/events/themes/{{id}}">{{title}}</a></h3>
+                {{#if description}}
+                <p class="theme-description">{{description}}</p>
+                {{/if}}
+                {{#if seo_keywords}}
+                <div class="theme-tags">
+                    {{#each seo_keywords}}
+                    <span class="tag">{{this}}</span>
+                    {{/each}}
+                </div>
+                {{/if}}
+                <a href="/events/themes/{{id}}" class="view-events-btn">View Events</a>
+            </div>
+            {{/each}}
+        </div>
+        
+        <footer>
+            <p><a href="/events">View all events</a> | <a href="/events/themes/api/config">Theme Config</a></p>
+        </footer>
+    </div>
+</body>
+</html>
+````
+
+````html
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{page_title}}</title>
+    {{#if page_description}}
+    <meta name="description" content="{{page_description}}">
+    {{/if}}
+    {{#if seo_keywords}}
+    <meta name="keywords" content="{{#each seo_keywords}}{{this}}{{#unless @last}}, {{/unless}}{{/each}}">
+    {{/if}}
+    <link rel="stylesheet" href="/css/events.css">
+    <link rel="stylesheet" href="/css/themes.css">
+</head>
+<body class="{{css_class}}">
+    <div class="themed-events-page">
+        <header>
+            <nav class="breadcrumb">
+                <a href="/events/themes">Themed Pages</a> > 
+                <span class="current">{{page_title}}</span>
+            </nav>
+            <h1>{{page_title}}</h1>
+            {{#if page_description}}
+            <p class="page-description">{{page_description}}</p>
+            {{/if}}
+        </header>
+        
+        <!-- Refinement filters form -->
+        <section class="filter-section">
+            <h3>Refine Results</h3>
+            <form method="get" class="theme-filters">
+                <div class="filter-group">
+                    {{#unless current_filters.name}}
+                    <div class="filter-item">
+                        <label for="name">Event name contains:</label>
+                        <input type="text" id="name" name="name" placeholder="Search event names...">
+                    </div>
+                    {{/unless}}
+                    
+                    {{#unless current_filters.description}}
+                    <div class="filter-item">
+                        <label for="description">Description contains:</label>
+                        <input type="text" id="description" name="description" placeholder="Search descriptions...">
+                    </div>
+                    {{/unless}}
+                    
+                    <!-- Date range refinement -->
+                    <div class="filter-item">
+                        <label for="starts_after">From date:</label>
+                        <input type="datetime-local" id="starts_after" name="starts_after">
+                    </div>
+                    
+                    <div class="filter-item">
+                        <label for="starts_before">To date:</label>
+                        <input type="datetime-local" id="starts_before" name="starts_before">
+                    </div>
+                    
+                    <!-- Additional mode/status filters if not constrained by theme -->
+                    {{#unless current_filters.mode}}
+                    <div class="filter-item">
+                        <label for="mode">Event mode:</label>
+                        <select id="mode" name="mode" multiple>
+                            <option value="inperson">In Person</option>
+                            <option value="virtual">Virtual</option>
+                            <option value="hybrid">Hybrid</option>
+                        </select>
+                    </div>
+                    {{/unless}}
+                </div>
+                
+                <div class="filter-actions">
+                    <button type="submit" class="btn btn-primary">Refine</button>
+                    <a href="/events/themes/{{theme_id}}" class="btn btn-secondary">Reset to Theme Defaults</a>
+                </div>
+            </form>
+        </section>
+        
+        <!-- Events listing -->
+        <section class="events-section">
+            <div class="results-header">
+                <h2>Events ({{total_count}} found)</h2>
+                <div class="view-options">
+                    <a href="/events" class="btn btn-outline">View All Events</a>
+                    <a href="/events/themes" class="btn btn-outline">Other Themes</a>
+                </div>
+            </div>
+            
+            {{#if events}}
+            <div class="events-list">
+                {{#each events}}
+                <div class="event-card" data-event-id="{{event.id}}">
+                    <div class="event-header">
+                        <h3 class="event-title">
+                            <a href="/events/{{event.id}}">{{event.title}}</a>
+                        </h3>
+                        {{#if event.status}}
+                        <span class="event-status status-{{event.status}}">{{event.status}}</span>
+                        {{/if}}
+                    </div>
+                    
+                    <div class="event-meta">
+                        {{#if event.starts_at}}
+                        <div class="event-date">
+                            <i class="icon-calendar"></i>
+                            <time datetime="{{event.starts_at}}">{{format_date event.starts_at}}</time>
+                        </div>
+                        {{/if}}
+                        
+                        {{#if event.mode}}
+                        <div class="event-mode">
+                            <i class="icon-{{event.mode}}"></i>
+                            <span>{{event.mode}}</span>
+                        </div>
+                        {{/if}}
+                        
+                        {{#if event.organizer}}
+                        <div class="event-organizer">
+                            <i class="icon-user"></i>
+                            <span>{{event.organizer.name}}</span>
+                        </div>
+                        {{/if}}
+                    </div>
+                    
+                    {{#if event.description}}
+                    <div class="event-description">
+                        <p>{{truncate event.description 150}}</p>
+                    </div>
+                    {{/if}}
+                    
+                    {{#if event.locations}}
+                    <div class="event-locations">
+                        <i class="icon-location"></i>
+                        {{#each event.locations}}
+                        <span class="location">{{name}}</span>{{#unless @last}}, {{/unless}}
+                        {{/each}}
+                    </div>
+                    {{/if}}
+                    
+                    <div class="event-actions">
+                        <a href="/events/{{event.id}}" class="btn btn-primary">View Details</a>
+                        {{#if event.uris}}
+                        {{#each event.uris}}
+                        {{#if (eq type "tickets")}}
+                        <a href="{{uri}}" class="btn btn-secondary" target="_blank" rel="noopener">Get Tickets</a>
+                        {{/if}}
+                        {{#if (eq type "registration")}}
+                        <a href="{{uri}}" class="btn btn-secondary" target="_blank" rel="noopener">Register</a>
+                        {{/if}}
+                        {{/each}}
+                        {{/if}}
+                    </div>
+                </div>
+                {{/each}}
+            </div>
+            {{else}}
+            <div class="no-events">
+                <h3>No events found</h3>
+                <p>Try adjusting your filters or <a href="/events/themes/{{theme_id}}">reset to theme defaults</a>.</p>
+            </div>
+            {{/if}}
+        </section>
+        
+        {{#if (gt total_count 20)}}
+        <section class="pagination">
+            <!-- Pagination controls would go here -->
+        </section>
+        {{/if}}
+    </div>
+    
+    <script src="/js/theme-filters.js"></script>
+</body>
+</html>
+````
+
+### Phase 7: Tests
+
+````rust
+use crate::cache::event_hydration::{EventHydrationCache, HydratedEvent};
+use crate::http::filters::EventFilters;
+use crate::services::event_filtering::EventFilteringService;
+use chrono::{DateTime, Utc};
+use std::collections::HashMap;
+
+#[cfg(test)]
+mod event_filtering_tests {
+    use super::*;
+    
+    #[tokio::test]
+    async fn test_text_filter_matching() {
+        let hydrated_event = create_test_event("Rust Programming Workshop", "Learn Rust programming language");
+        let filters = EventFilters {
+            name: Some(vec!["rust".to_string()]),
+            ..Default::default()
+        };
+        
+        let service = create_test_service().await;
+        assert!(service.should_include_event(&hydrated_event, &filters));
+        
+        let filters_no_match = EventFilters {
+            name: Some(vec!["python".to_string()]),
+            ..Default::default()
+        };
+        assert!(!service.should_include_event(&hydrated_event, &filters_no_match));
+    }
+    
+    #[tokio::test]
+    async fn test_status_filter_matching() {
+        let mut hydrated_event = create_test_event("Test Event", "Description");
+        hydrated_event.status = Some(Status::Scheduled);
+        
+        let filters = EventFilters {
+            status: Some(vec!["scheduled".to_string()]),
+            ..Default::default()
+        };
+        
+        let service = create_test_service().await;
+        assert!(service.should_include_event(&hydrated_event, &filters));
+        
+        let filters_no_match = EventFilters {
+            status: Some(vec!["cancelled".to_string()]),
+            ..Default::default()
+        };
+        assert!(!service.should_include_event(&hydrated_event, &filters_no_match));
+    }
+    
+    #[tokio::test]
+    async fn test_mode_filter_matching() {
+        let mut hydrated_event = create_test_event("Test Event", "Description");
+        hydrated_event.mode = Some(Mode::Virtual);
+        
+        let filters = EventFilters {
+            mode: Some(vec!["virtual".to_string()]),
+            ..Default::default()
+        };
+        
+        let service = create_test_service().await;
+        assert!(service.should_include_event(&hydrated_event, &filters));
+        
+        let filters_no_match = EventFilters {
+            mode: Some(vec!["inperson".to_string()]),
+            ..Default::default()
+        };
+        assert!(!service.should_include_event(&hydrated_event, &filters_no_match));
+    }
+    
+    #[tokio::test]
+    async fn test_date_range_filtering() {
+        let mut hydrated_event = create_test_event("Test Event", "Description");
+        let event_start = Utc::now() + chrono::Duration::days(5);
+        hydrated_event.starts_at = Some(event_start);
+        
+        // Test starts_after filter
+        let filters_after = EventFilters {
+            starts_after: Some(Utc::now() + chrono::Duration::days(3)),
+            ..Default::default()
+        };
+        
+        let service = create_test_service().await;
+        assert!(service.should_include_event(&hydrated_event, &filters_after));
+        
+        // Test starts_before filter
+        let filters_before = EventFilters {
+            starts_before: Some(Utc::now() + chrono::Duration::days(7)),
+            ..Default::default()
+        };
+        assert!(service.should_include_event(&hydrated_event, &filters_before));
+        
+        // Test out of range
+        let filters_out_of_range = EventFilters {
+            starts_after: Some(Utc::now() + chrono::Duration::days(10)),
+            ..Default::default()
+        };
+        assert!(!service.should_include_event(&hydrated_event, &filters_out_of_range));
+    }
+    
+    #[tokio::test]
+    async fn test_location_filtering() {
+        let mut hydrated_event = create_test_event("Test Event", "Description");
+        hydrated_event.locations = vec![
+            EventLocation {
+                name: "San Francisco Tech Hub".to_string(),
+                // ... other fields
+            },
+            EventLocation {
+                name: "Virtual Platform".to_string(),
+                // ... other fields
+            },
+        ];
+        
+        let filters = EventFilters {
+            location_name: Some(vec!["san francisco".to_string()]),
+            ..Default::default()
+        };
+        
+        let service = create_test_service().await;
+        assert!(service.should_include_event(&hydrated_event, &filters));
+        
+        let filters_no_match = EventFilters {
+            location_name: Some(vec!["new york".to_string()]),
+            ..Default::default()
+        };
+        assert!(!service.should_include_event(&hydrated_event, &filters_no_match));
+    }
+    
+    #[tokio::test]
+    async fn test_extra_fields_filtering() {
+        let mut hydrated_event = create_test_event("Test Event", "Description");
+        let mut extra = HashMap::new();
+        extra.insert("category".to_string(), serde_json::Value::String("technology".to_string()));
+        extra.insert("cost".to_string(), serde_json::Value::String("free".to_string()));
+        hydrated_event.extra = extra;
+        
+        // Test extra keys filter
+        let filters_keys = EventFilters {
+            extra_keys: Some(vec!["category".to_string()]),
+            ..Default::default()
+        };
+        
+        let service = create_test_service().await;
+        assert!(service.should_include_event(&hydrated_event, &filters_keys));
+        
+        // Test extra values filter
+        let mut extra_values = HashMap::new();
+        extra_values.insert("cost".to_string(), vec!["free".to_string()]);
+        let filters_values = EventFilters {
+            extra_values: Some(extra_values),
+            ..Default::default()
+        };
+        assert!(service.should_include_event(&hydrated_event, &filters_values));
+        
+        // Test no match
+        let mut extra_values_no_match = HashMap::new();
+        extra_values_no_match.insert("cost".to_string(), vec!["paid".to_string()]);
+        let filters_no_match = EventFilters {
+            extra_values: Some(extra_values_no_match),
+            ..Default::default()
+        };
+        assert!(!service.should_include_event(&hydrated_event, &filters_no_match));
+    }
+    
+    #[tokio::test]
+    async fn test_filter_merging() {
+        let base_filters = EventFilters {
+            mode: Some(vec!["virtual".to_string()]),
+            status: Some(vec!["scheduled".to_string(), "planned".to_string()]),
+            starts_after: Some(Utc::now()),
+            ..Default::default()
+        };
+        
+        let user_filters = EventFilters {
+            mode: Some(vec!["virtual".to_string(), "hybrid".to_string()]),
+            name: Some(vec!["conference".to_string()]),
+            starts_after: Some(Utc::now() + chrono::Duration::days(1)),
+            ..Default::default()
+        };
+        
+        let merged = user_filters.merge_with_base(&base_filters);
+        
+        // Mode should be intersection (only "virtual")
+        assert_eq!(merged.mode, Some(vec!["virtual".to_string()]));
+        
+        // Name should come from user filters
+        assert_eq!(merged.name, Some(vec!["conference".to_string()]));
+        
+        // Status should come from base (user didn't specify)
+        assert_eq!(merged.status, Some(vec!["scheduled".to_string(), "planned".to_string()]));
+        
+        // starts_after should be the later date (more restrictive)
+        assert!(merged.starts_after.unwrap() > base_filters.starts_after.unwrap());
+    }
+    
+    // Helper functions for tests
+    fn create_test_event(name: &str, description: &str) -> HydratedEvent {
+        HydratedEvent {
+            name: name.to_string(),
+            description: description.to_string(),
+            starts_at: None,
+            ends_at: None,
+            mode: None,
+            status: None,
+            locations: Vec::new(),
+            uris: Vec::new(),
+            extra: HashMap::new(),
+        }
+    }
+    
+    async fn create_test_service() -> EventFilteringService {
+        // Create mock cache for testing
+        let mock_cache = create_mock_hydration_cache().await;
+        EventFilteringService::new(mock_cache)
+    }
+    
+    async fn create_mock_hydration_cache() -> EventHydrationCache {
+        // Implementation would create a mock Redis pool for testing
+        unimplemented!("Create mock Redis pool for tests")
+    }
+}
+````
+
+````rust
+use crate::config::themed_pages::{load_themed_pages_config, validate_themed_config, ThemedPagesConfig, ThemedPageConfig};
+use crate::http::filters::EventFilters;
+
+#[cfg(test)]
+mod themed_pages_tests {
+    use super::*;
+    
+    #[test]
+    fn test_default_themed_config() {
+        let config = ThemedPagesConfig::default();
+        assert!(config.pages.len() > 0);
+        
+        // Validate the default configuration
+        assert!(validate_themed_config(&config).is_ok());
+        
+        // Check that virtual events theme exists
+        let virtual_theme = config.pages.iter().find(|p| p.id == "virtual-events");
+        assert!(virtual_theme.is_some());
+        
+        let theme = virtual_theme.unwrap();
+        assert_eq!(theme.title, "Virtual Events");
+        assert!(theme.enabled);
+        assert!(theme.base_filters.mode.as_ref().unwrap().contains(&"virtual".to_string()));
+    }
+    
+    #[test]
+    fn test_themed_config_validation() {
+        // Test valid configuration
+        let valid_config = ThemedPagesConfig {
+            pages: vec![
+                ThemedPageConfig {
+                    id: "test-theme".to_string(),
+                    title: "Test Theme".to_string(),
+                    description: Some("Test description".to_string()),
+                    base_filters: EventFilters::default(),
+                    template_name: Some("test_template".to_string()),
+                    css_class: Some("test-class".to_string()),
+                    enabled: true,
+                    seo_keywords: None,
+                    cache_ttl: Some(3600),
+                },
+            ],
+        };
+        assert!(validate_themed_config(&valid_config).is_ok());
+        
+        // Test duplicate IDs
+        let duplicate_config = ThemedPagesConfig {
+            pages: vec![
+                ThemedPageConfig {
+                    id: "duplicate".to_string(),
+                    title: "First".to_string(),
+                    description: None,
+                    base_filters: EventFilters::default(),
+                    template_name: None,
+                    css_class: None,
+                    enabled: true,
+                    seo_keywords: None,
+                    cache_ttl: None,
+                },
+                ThemedPageConfig {
+                    id: "duplicate".to_string(),
+                    title: "Second".to_string(),
+                    description: None,
+                    base_filters: EventFilters::default(),
+                    template_name: None,
+                    css_class: None,
+                    enabled: true,
+                    seo_keywords: None,
+                    cache_ttl: None,
+                },
+            ],
+        };
+        assert!(validate_themed_config(&duplicate_config).is_err());
+        
+        // Test invalid ID format
+        let invalid_id_config = ThemedPagesConfig {
+            pages: vec![
+                ThemedPageConfig {
+                    id: "invalid/id".to_string(),
+                    title: "Invalid".to_string(),
+                    description: None,
+                    base_filters: EventFilters::default(),
+                    template_name: None,
+                    css_class: None,
+                    enabled: true,
+                    seo_keywords: None,
+                    cache_ttl: None,
+                },
+            ],
+        };
+        assert!(validate_themed_config(&invalid_id_config).is_err());
+        
+        // Test zero cache TTL
+        let zero_ttl_config = ThemedPagesConfig {
+            pages: vec![
+                ThemedPageConfig {
+                    id: "zero-ttl".to_string(),
+                    title: "Zero TTL".to_string(),
+                    description: None,
+                    base_filters: EventFilters::default(),
+                    template_name: None,
+                    css_class: None,
+                    enabled: true,
+                    seo_keywords: None,
+                    cache_ttl: Some(0),
+                },
+            ],
+        };
+        assert!(validate_themed_config(&zero_ttl_config).is_err());
+    }
+    
+    #[test]
+    fn test_filter_merging_edge_cases() {
+        let base = EventFilters {
+            status: Some(vec!["scheduled".to_string()]),
+            mode: Some(vec!["virtual".to_string(), "hybrid".to_string()]),
+            ..Default::default()
+        };
+        
+        // User specifies mode not in base - should fall back to base
+        let user = EventFilters {
+            mode: Some(vec!["inperson".to_string()]),
+            ..Default::default()
+        };
+        
+        let merged = user.merge_with_base(&base);
+        assert_eq!(merged.mode, Some(vec!["virtual".to_string(), "hybrid".to_string()]));
+        
+        // User specifies overlapping mode - should intersect
+        let user_overlap = EventFilters {
+            mode: Some(vec!["virtual".to_string()]),
+            ..Default::default()
+        };
+        
+        let merged_overlap = user_overlap.merge_with_base(&base);
+        assert_eq!(merged_overlap.mode, Some(vec!["virtual".to_string()]));
+    }
+}
+````

src/http/handle_events_filtered_backup.rs

···
-use anyhow::Result;
-use axum::{
-    extract::{Query, State, Form},
-    response::IntoResponse,
-};
-use axum_extra::extract::Cached;
-use axum_htmx::{HxBoosted, HxRequest};
-use axum_template::RenderHtml;
-
-use chrono::{DateTime, TimeZone, Utc};
-use minijinja::context as template_context;
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    contextual_error,
-    http::{
-        context::WebContext,
-        errors::WebError,
-        event_view::{hydrate_event_organizers, hydrate_event_rsvp_counts, EventView},
-        middleware_auth::Auth,
-        middleware_i18n::Language,
-        pagination::{Pagination, PaginationView},
-    },
-    select_template,
-    storage::{
-        event::model::EventWithRole,
-        event_filter::{event_list_filtered, EventFilterOptions},
-    },
-};
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct EventFilters {
-    status: Option<String>,
-    mode: Option<String>,
-    starts_after: Option<String>,      // Format ISO 8601 or YYYY-MM-DD
-    starts_after_time: Option<String>, // Format HH:MM
-    starts_before: Option<String>,     // Format ISO 8601 or YYYY-MM-DD
-    starts_before_time: Option<String>, // Format HH:MM
-    organizer: Option<String>,
-    sort_by: Option<String>,           // "starts_at" for sorting by start date, "updated_at" (default) for recently updated
-}
-
-pub async fn handle_events_filtered(
-    State(web_context): State<WebContext>,
-    HxBoosted(hx_boosted): HxBoosted,
-    HxRequest(hx_request): HxRequest,
-    Language(language): Language,
-    Cached(auth): Cached<Auth>,
-    pagination: Query<Pagination>,
-    filters: Query<EventFilters>,
-) -> Result<impl IntoResponse, WebError> {
-    // Déléguer à la fonction commune avec les filtres de l'URL (GET)
-    handle_events_filtered_common(
-        web_context,
-        hx_boosted,
-        hx_request,
-        language,
-        auth,
-        pagination.0,
-        filters.0,
-    ).await
-}
-
-// Handler pour les requêtes POST (formulaires)
-pub async fn handle_events_filtered_post(
-    State(web_context): State<WebContext>,
-    HxBoosted(hx_boosted): HxBoosted,
-    HxRequest(hx_request): HxRequest,
-    Language(language): Language,
-    Cached(auth): Cached<Auth>,
-    pagination: Query<Pagination>,
-    Form(filters): Form<EventFilters>,
-) -> Result<impl IntoResponse, WebError> {
-    // Déléguer à la fonction commune avec les filtres du formulaire
-    handle_events_filtered_common(
-        web_context,
-        hx_boosted,
-        hx_request,
-        language,
-        auth,
-        pagination.0,
-        filters,
-    ).await
-}
-
-// Fonction commune pour traiter les filtres d'événements
-async fn handle_events_filtered_common(
-    web_context: WebContext,
-    hx_boosted: bool,
-    hx_request: bool,
-    language: Language,
-    auth: Auth,
-    pagination: Pagination,
-    filters: EventFilters,
-) -> Result<impl IntoResponse, WebError> {
-    let render_template = select_template!("events_filtered", hx_boosted, hx_request, language);
-    let error_template = select_template!(false, false, language);
-
-    let (page, page_size) = pagination.clamped();
-    
-    // Create a mutable copy of the filters to be able to add default values if necessary
-    let mut filters_with_defaults = filters.clone();
-    
-    // If no date is specified (first visit to the page), we add default values
-    let is_first_visit = filters.starts_after.as_ref().map_or(true, |s| s.is_empty() || s == "none") &&
-                        filters.starts_before.as_ref().map_or(true, |s| s.is_empty() || s == "none");
-                        
-    if is_first_visit {
-        // Today
-        let today = chrono::Local::now().date_naive();
-        // Tomorrow (today + 24h)
-        let tomorrow = today.succ_opt().unwrap_or(today);
-        
-        // Date format as YYYY-MM-DD
-        filters_with_defaults.starts_after = Some(today.format("%Y-%m-%d").to_string());
-        filters_with_defaults.starts_after_time = Some("00:00".to_string());
-        filters_with_defaults.starts_before = Some(tomorrow.format("%Y-%m-%d").to_string());
-        filters_with_defaults.starts_before_time = Some("23:59".to_string());
-        
-        tracing::debug!("Adding default values for dates: {} - {}", 
-            filters_with_defaults.starts_after.as_ref().unwrap(), 
-            filters_with_defaults.starts_before.as_ref().unwrap());
-    }
-    
-    // Date and time conversion if present
-    let starts_after = filters_with_defaults.starts_after.as_ref()
-        .filter(|&date_str| !date_str.is_empty() && date_str != "none")
-        .and_then(|date_str| {
-            let time_str = filters_with_defaults.starts_after_time.as_deref().unwrap_or("00:00");
-            
-            // Try parsing in YYYY-MM-DD format (HTML input type=date format)
-            if let Some(date) = chrono::NaiveDate::parse_from_str(date_str, "%Y-%m-%d").ok() {
-                let time = chrono::NaiveTime::parse_from_str(time_str, "%H:%M")
-                    .unwrap_or_else(|_| chrono::NaiveTime::from_hms_opt(0, 0, 0).unwrap());
-                
-                // Convert NaiveDate to DateTime<Utc> with specified time
-                let naive_datetime = chrono::NaiveDateTime::new(date, time);
-                Some(Utc.from_utc_datetime(&naive_datetime))
-            } else {
-                // Fallback to RFC3339 format
-                DateTime::parse_from_rfc3339(date_str).ok().map(|date| date.with_timezone(&Utc))
-            }
-        });
-        
-    let starts_before = filters_with_defaults.starts_before.as_ref()
-        .filter(|&date_str| !date_str.is_empty() && date_str != "none")
-        .and_then(|date_str| {
-            let time_str = filters_with_defaults.starts_before_time.as_deref().unwrap_or("23:59");
-            
-            // Try parsing in YYYY-MM-DD format (HTML input type=date format)
-            if let Some(date) = chrono::NaiveDate::parse_from_str(date_str, "%Y-%m-%d").ok() {
-                let time = chrono::NaiveTime::parse_from_str(time_str, "%H:%M")
-                    .unwrap_or_else(|_| chrono::NaiveTime::from_hms_opt(23, 59, 59).unwrap());
-                
-                // Convert NaiveDate to DateTime<Utc> with specified time
-                let naive_datetime = chrono::NaiveDateTime::new(date, time);
-                Some(Utc.from_utc_datetime(&naive_datetime))
-            } else {
-                // Fallback to RFC3339 format
-                DateTime::parse_from_rfc3339(date_str).ok().map(|date| date.with_timezone(&Utc))
-            }
-        });
-    
-    // Create filtering options
-    let filter_options = EventFilterOptions {
-        status: filters_with_defaults.status.clone(),
-        mode: filters_with_defaults.mode.clone(),
-        starts_after,
-        starts_before,
-        organizer_did: filters_with_defaults.organizer.clone(),
-        sort_by: filters_with_defaults.sort_by.clone(),
-    };
-    
-    // Log filtering parameters for debugging
-    tracing::debug!(
-        "Event filtering: status={:?}, mode={:?}, starts_after={:?} {:?} ({:?}), starts_before={:?} {:?} ({:?}), organizer={:?}, sort_by={:?}",
-        filters_with_defaults.status, filters_with_defaults.mode, 
-        filters_with_defaults.starts_after, filters_with_defaults.starts_after_time, starts_after,
-        filters_with_defaults.starts_before, filters_with_defaults.starts_before_time, starts_before,
-        filters_with_defaults.organizer, filters_with_defaults.sort_by
-    );
-    
-    // Retrieve filtered events
-    let (total_count, events) = match event_list_filtered(&web_context.pool, filter_options, page, page_size).await {
-        Ok((count, events)) => {
-            tracing::debug!("Events found: {}", count);
-            (count, events)
-        },
-        Err(err) => {
-            return contextual_error!(
-                web_context,
-                language,
-                error_template,
-                template_context! {},
-                err
-            );
-        }
-    };
-
-    // Convert to EventWithRole for hydration
-    let event_with_roles = events.into_iter()
-        .map(|event| EventWithRole {
-            event,
-            role: "".to_string(),
-        })
-        .collect::<Vec<_>>();
-    
-    let organizer_handlers = hydrate_event_organizers(&web_context.pool, &event_with_roles).await?;
-
-    // Convert to event views
-    let mut event_views = event_with_roles
-        .iter()
-        .filter_map(|event_role| {
-            let organizer_maybe = organizer_handlers.get(&event_role.event.did);
-            let event_view =
-                EventView::try_from((auth.0.as_ref(), organizer_maybe, &event_role.event));
-
-            match event_view {
-                Ok(event_view) => Some(event_view),
-                Err(err) => {
-                    tracing::warn!(err = ?err, "error converting event view");
-                    None
-                }
-            }
-        })
-        .collect::<Vec<EventView>>();
-
-    // Add RSVP counts
-    if let Err(err) = hydrate_event_rsvp_counts(&web_context.pool, &mut event_views).await {
-        tracing::warn!("Failed to hydrate event counts: {}", err);
-    }
-
-    // Prepare parameters for pagination view
-    let mut params: Vec<(&str, &str)> = Vec::new();
-    if let Some(status) = &filters_with_defaults.status {
-        params.push(("status", status));
-    }
-    if let Some(mode) = &filters_with_defaults.mode {
-        params.push(("mode", mode));
-    }
-    if let Some(starts_after) = &filters_with_defaults.starts_after {
-        params.push(("starts_after", starts_after));
-    }
-    if let Some(starts_after_time) = &filters_with_defaults.starts_after_time {
-        params.push(("starts_after_time", starts_after_time));
-    }
-    if let Some(starts_before) = &filters_with_defaults.starts_before {
-        params.push(("starts_before", starts_before));
-    }
-    if let Some(starts_before_time) = &filters_with_defaults.starts_before_time {
-        params.push(("starts_before_time", starts_before_time));
-    }
-    if let Some(organizer) = &filters_with_defaults.organizer {
-        params.push(("organizer", organizer));
-    }
-    if let Some(sort_by) = &filters_with_defaults.sort_by {
-        params.push(("sort_by", sort_by));
-    }
-
-    let pagination_view = PaginationView::new(page_size, total_count, page, params);
-
-    // Limit results to page size
-    if event_views.len() > page_size as usize {
-        event_views.truncate(page_size as usize);
-    }
-
-    // Build context for template
-    Ok((
-        http::StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
-            template_context! {
-                current_handle => auth.0,
-                language => language.to_string(),
-                canonical_url => format!("https://{}/events", web_context.config.external_base),
-                events => event_views,
-                pagination => pagination_view,
-                filters => filters_with_defaults,
-                total_count => total_count,
-            },
-        ),
-    )
-        .into_response())
-}
-
-/// Handler pour les requêtes HTMX partielles de mise à jour des résultats d'événements
-/// Utilisé par le formulaire de filtres pour mettre à jour la zone des résultats
-pub async fn handle_events_results(
-    State(web_context): State<WebContext>,
-    Language(language): Language,
-    Cached(auth): Cached<Auth>,
-    pagination: Query<Pagination>,
-    filters: Query<EventFilters>,
-) -> Result<impl IntoResponse, WebError> {
-    // Toujours utiliser le template partial pour les résultats
-    let render_template = select_template!("events_filtered", false, true, language);
-    let error_template = select_template!(false, false, language);
-
-    // Réutiliser la même logique de filtrage que le handler principal
-    let (page, page_size) = pagination.clamped();
-    
-    // Use the filters directly without needing to make them mutable
-    let filters_with_defaults = filters.0.clone();
-    
-    // Date and time conversion if present
-    let starts_after = filters_with_defaults.starts_after.as_ref()
-        .filter(|&date_str| !date_str.is_empty() && date_str != "none")
-        .and_then(|date_str| {
-            let time_str = filters_with_defaults.starts_after_time.as_deref().unwrap_or("00:00");
-            
-            // Try parsing in YYYY-MM-DD format (HTML input type=date format)
-            if let Some(date) = chrono::NaiveDate::parse_from_str(date_str, "%Y-%m-%d").ok() {
-                let time = chrono::NaiveTime::parse_from_str(time_str, "%H:%M")
-                    .unwrap_or_else(|_| chrono::NaiveTime::from_hms_opt(0, 0, 0).unwrap());
-                
-                // Convert NaiveDate to DateTime<Utc> with specified time
-                let naive_datetime = chrono::NaiveDateTime::new(date, time);
-                Some(Utc.from_utc_datetime(&naive_datetime))
-            } else {
-                // Fallback to RFC3339 format
-                DateTime::parse_from_rfc3339(date_str).ok().map(|date| date.with_timezone(&Utc))
-            }
-        });
-        
-    let starts_before = filters_with_defaults.starts_before.as_ref()
-        .filter(|&date_str| !date_str.is_empty() && date_str != "none")
-        .and_then(|date_str| {
-            let time_str = filters_with_defaults.starts_before_time.as_deref().unwrap_or("23:59");
-            
-            // Try parsing in YYYY-MM-DD format (HTML input type=date format)
-            if let Some(date) = chrono::NaiveDate::parse_from_str(date_str, "%Y-%m-%d").ok() {
-                let time = chrono::NaiveTime::parse_from_str(time_str, "%H:%M")
-                    .unwrap_or_else(|_| chrono::NaiveTime::from_hms_opt(23, 59, 59).unwrap());
-                
-                // Convert NaiveDate to DateTime<Utc> with specified time
-                let naive_datetime = chrono::NaiveDateTime::new(date, time);
-                Some(Utc.from_utc_datetime(&naive_datetime))
-            } else {
-                // Fallback to RFC3339 format
-                DateTime::parse_from_rfc3339(date_str).ok().map(|date| date.with_timezone(&Utc))
-            }
-        });
-    
-    // Create filtering options
-    let filter_options = EventFilterOptions {
-        status: filters_with_defaults.status.clone(),
-        mode: filters_with_defaults.mode.clone(),
-        starts_after,
-        starts_before,
-        organizer_did: filters_with_defaults.organizer.clone(),
-        sort_by: filters_with_defaults.sort_by.clone(),
-    };
-    
-    // Log filtering parameters for debugging
-    tracing::debug!(
-        "Event filtering (HTMX partial): status={:?}, mode={:?}, starts_after={:?} {:?} ({:?}), starts_before={:?} {:?} ({:?}), organizer={:?}, sort_by={:?}",
-        filters_with_defaults.status, filters_with_defaults.mode, 
-        filters_with_defaults.starts_after, filters_with_defaults.starts_after_time, starts_after,
-        filters_with_defaults.starts_before, filters_with_defaults.starts_before_time, starts_before,
-        filters_with_defaults.organizer, filters_with_defaults.sort_by
-    );
-    
-    // Retrieve filtered events
-    let (total_count, events) = match event_list_filtered(&web_context.pool, filter_options, page, page_size).await {
-        Ok((count, events)) => {
-            tracing::debug!("Events found (HTMX partial): {}", count);
-            (count, events)
-        },
-        Err(err) => {
-            return contextual_error!(
-                web_context,
-                language,
-                error_template,
-                template_context! {},
-                err
-            );
-        }
-    };
-
-    // Convert to EventWithRole for hydration
-    let event_with_roles = events.into_iter()
-        .map(|event| EventWithRole {
-            event,
-            role: "".to_string(),
-        })
-        .collect::<Vec<_>>();
-    
-    let organizer_handlers = hydrate_event_organizers(&web_context.pool, &event_with_roles).await?;
-
-    // Convert to event views
-    let mut event_views = event_with_roles
-        .iter()
-        .filter_map(|event_role| {
-            let organizer_maybe = organizer_handlers.get(&event_role.event.did);
-            let event_view =
-                EventView::try_from((auth.0.as_ref(), organizer_maybe, &event_role.event));
-
-            match event_view {
-                Ok(event_view) => Some(event_view),
-                Err(err) => {
-                    tracing::warn!(err = ?err, "error converting event view");
-                    None
-                }
-            }
-        })
-        .collect::<Vec<EventView>>();
-
-    // Add RSVP counts
-    if let Err(err) = hydrate_event_rsvp_counts(&web_context.pool, &mut event_views).await {
-        tracing::warn!("Failed to hydrate event counts: {}", err);
-    }
-
-    // Prepare parameters for pagination view
-    let mut params: Vec<(&str, &str)> = Vec::new();
-    if let Some(status) = &filters_with_defaults.status {
-        params.push(("status", status));
-    }
-    if let Some(mode) = &filters_with_defaults.mode {
-        params.push(("mode", mode));
-    }
-    if let Some(starts_after) = &filters_with_defaults.starts_after {
-        params.push(("starts_after", starts_after));
-    }
-    if let Some(starts_after_time) = &filters_with_defaults.starts_after_time {
-        params.push(("starts_after_time", starts_after_time));
-    }
-    if let Some(starts_before) = &filters_with_defaults.starts_before {
-        params.push(("starts_before", starts_before));
-    }
-    if let Some(starts_before_time) = &filters_with_defaults.starts_before_time {
-        params.push(("starts_before_time", starts_before_time));
-    }
-    if let Some(organizer) = &filters_with_defaults.organizer {
-        params.push(("organizer", organizer));
-    }
-    if let Some(sort_by) = &filters_with_defaults.sort_by {
-        params.push(("sort_by", sort_by));
-    }
-
-    let pagination_view = PaginationView::new(page_size, total_count, page, params);
-
-    // Limit results to page size
-    if event_views.len() > page_size as usize {
-        event_views.truncate(page_size as usize);
-    }
-
-    // Build context for template (partial)
-    Ok((
-        http::StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
-            template_context! {
-                current_handle => auth.0,
-                language => language.to_string(),
-                events => event_views,
-                pagination => pagination_view,
-                filters => filters_with_defaults,
-                total_count => total_count,
-            },
-        ),
-    )
-        .into_response())
-}
-
-/// Handler pour les requêtes POST (formulaires)
-pub async fn handle_events_filtered_post(
-    State(web_context): State<WebContext>,
-    HxBoosted(hx_boosted): HxBoosted,
-    HxRequest(hx_request): HxRequest,
-    Language(language): Language,
-    Cached(auth): Cached<Auth>,
-    pagination: Query<Pagination>,
-    Form(filters): Form<EventFilters>,
-) -> Result<impl IntoResponse, WebError> {
-    // Déléguer à la fonction commune avec les filtres du formulaire
-    handle_events_filtered_common(
-        web_context,
-        hx_boosted,
-        hx_request,
-        language,
-        auth,
-        pagination.0,
-        filters,
-    ).await
-}
-
-/// Handler pour les requêtes GET (liens directs)
-pub async fn handle_events_filtered_get(
-    State(web_context): State<WebContext>,
-    HxBoosted(hx_boosted): HxBoosted,
-    HxRequest(hx_request): HxRequest,
-    Language(language): Language,
-    Cached(auth): Cached<Auth>,
-    pagination: Query<Pagination>,
-    filters: Query<EventFilters>,
-) -> Result<impl IntoResponse, WebError> {
-    // Déléguer à la fonction commune avec les filtres de l'URL
-    handle_events_filtered_common(
-        web_context,
-        hx_boosted,
-        hx_request,
-        language,
-        auth,
-        pagination.0,
-        filters.0,
-    ).await
-}
-
-/// Fonction commune pour traiter les filtres d'événements
-async fn handle_events_filtered_common(
-    web_context: WebContext,
-    hx_boosted: bool,
-    hx_request: bool,
-    language: Language,
-    auth: Auth,
-    pagination: Pagination,
-    filters: EventFilters,
-) -> Result<impl IntoResponse, WebError> {
-    let render_template = select_template!("events_filtered", hx_boosted, hx_request, language);
-    let error_template = select_template!(false, false, language);
-
-    let (page, page_size) = pagination.clamped();
-    
-    // Create a mutable copy of the filters to be able to add default values if necessary
-    let mut filters_with_defaults = filters.clone();
-    
-    // If no date is specified (first visit to the page), we add default values
-    let is_first_visit = filters.starts_after.as_ref().map_or(true, |s| s.is_empty() || s == "none") &&
-                        filters.starts_before.as_ref().map_or(true, |s| s.is_empty() || s == "none");
-                        
-    if is_first_visit {
-        // Today
-        let today = chrono::Local::now().date_naive();
-        // Tomorrow (today + 24h)
-        let tomorrow = today.succ_opt().unwrap_or(today);
-        
-        // Date format as YYYY-MM-DD
-        filters_with_defaults.starts_after = Some(today.format("%Y-%m-%d").to_string());
-        filters_with_defaults.starts_after_time = Some("00:00".to_string());
-        filters_with_defaults.starts_before = Some(tomorrow.format("%Y-%m-%d").to_string());
-        filters_with_defaults.starts_before_time = Some("23:59".to_string());
-        
-        tracing::debug!("Adding default values for dates: {} - {}", 
-            filters_with_defaults.starts_after.as_ref().unwrap(), 
-            filters_with_defaults.starts_before.as_ref().unwrap());
-    }
-    
-    // Date and time conversion if present
-    let starts_after = filters_with_defaults.starts_after.as_ref()
-        .filter(|&date_str| !date_str.is_empty() && date_str != "none")
-        .and_then(|date_str| {
-            let time_str = filters_with_defaults.starts_after_time.as_deref().unwrap_or("00:00");
-            
-            // Try parsing in YYYY-MM-DD format (HTML input type=date format)
-            if let Some(date) = chrono::NaiveDate::parse_from_str(date_str, "%Y-%m-%d").ok() {
-                let time = chrono::NaiveTime::parse_from_str(time_str, "%H:%M")
-                    .unwrap_or_else(|_| chrono::NaiveTime::from_hms_opt(0, 0, 0).unwrap());
-                
-                // Convert NaiveDate to DateTime<Utc> with specified time
-                let naive_datetime = chrono::NaiveDateTime::new(date, time);
-                Some(Utc.from_utc_datetime(&naive_datetime))
-            } else {
-                // Fallback to RFC3339 format
-                DateTime::parse_from_rfc3339(date_str).ok().map(|date| date.with_timezone(&Utc))
-            }
-        });
-        
-    let starts_before = filters_with_defaults.starts_before.as_ref()
-        .filter(|&date_str| !date_str.is_empty() && date_str != "none")
-        .and_then(|date_str| {
-            let time_str = filters_with_defaults.starts_before_time.as_deref().unwrap_or("23:59");
-            
-            // Try parsing in YYYY-MM-DD format (HTML input type=date format)
-            if let Some(date) = chrono::NaiveDate::parse_from_str(date_str, "%Y-%m-%d").ok() {
-                let time = chrono::NaiveTime::parse_from_str(time_str, "%H:%M")
-                    .unwrap_or_else(|_| chrono::NaiveTime::from_hms_opt(23, 59, 59).unwrap());
-                
-                // Convert NaiveDate to DateTime<Utc> with specified time
-                let naive_datetime = chrono::NaiveDateTime::new(date, time);
-                Some(Utc.from_utc_datetime(&naive_datetime))
-            } else {
-                // Fallback to RFC3339 format
-                DateTime::parse_from_rfc3339(date_str).ok().map(|date| date.with_timezone(&Utc))
-            }
-        });
-    
-    // Create filtering options
-    let filter_options = EventFilterOptions {
-        status: filters_with_defaults.status.clone(),
-        mode: filters_with_defaults.mode.clone(),
-        starts_after,
-        starts_before,
-        organizer_did: filters_with_defaults.organizer.clone(),
-        sort_by: filters_with_defaults.sort_by.clone(),
-    };
-    
-    // Log filtering parameters for debugging
-    tracing::debug!(
-        "Event filtering: status={:?}, mode={:?}, starts_after={:?} {:?} ({:?}), starts_before={:?} {:?} ({:?}), organizer={:?}, sort_by={:?}",
-        filters_with_defaults.status, filters_with_defaults.mode, 
-        filters_with_defaults.starts_after, filters_with_defaults.starts_after_time, starts_after,
-        filters_with_defaults.starts_before, filters_with_defaults.starts_before_time, starts_before,
-        filters_with_defaults.organizer, filters_with_defaults.sort_by
-    );
-    
-    // Retrieve filtered events
-    let (total_count, events) = match event_list_filtered(&web_context.pool, filter_options, page, page_size).await {
-        Ok((count, events)) => {
-            tracing::debug!("Events found: {}", count);
-            (count, events)
-        },
-        Err(err) => {
-            return contextual_error!(
-                web_context,
-                language,
-                error_template,
-                template_context! {},
-                err
-            );
-        }
-    };
-
-    // Convert to EventWithRole for hydration
-    let event_with_roles = events.into_iter()
-        .map(|event| EventWithRole {
-            event,
-            role: "".to_string(),
-        })
-        .collect::<Vec<_>>();
-    
-    let organizer_handlers = hydrate_event_organizers(&web_context.pool, &event_with_roles).await?;
-
-    // Convert to event views
-    let mut event_views = event_with_roles
-        .iter()
-        .filter_map(|event_role| {
-            let organizer_maybe = organizer_handlers.get(&event_role.event.did);
-            let event_view =
-                EventView::try_from((auth.0.as_ref(), organizer_maybe, &event_role.event));
-
-            match event_view {
-                Ok(event_view) => Some(event_view),
-                Err(err) => {
-                    tracing::warn!(err = ?err, "error converting event view");
-                    None
-                }
-            }
-        })
-        .collect::<Vec<EventView>>();
-
-    // Add RSVP counts
-    if let Err(err) = hydrate_event_rsvp_counts(&web_context.pool, &mut event_views).await {
-        tracing::warn!("Failed to hydrate event counts: {}", err);
-    }
-
-    // Prepare parameters for pagination view
-    let mut params: Vec<(&str, &str)> = Vec::new();
-    if let Some(status) = &filters_with_defaults.status {
-        params.push(("status", status));
-    }
-    if let Some(mode) = &filters_with_defaults.mode {
-        params.push(("mode", mode));
-    }
-    if let Some(starts_after) = &filters_with_defaults.starts_after {
-        params.push(("starts_after", starts_after));
-    }
-    if let Some(starts_after_time) = &filters_with_defaults.starts_after_time {
-        params.push(("starts_after_time", starts_after_time));
-    }
-    if let Some(starts_before) = &filters_with_defaults.starts_before {
-        params.push(("starts_before", starts_before));
-    }
-    if let Some(starts_before_time) = &filters_with_defaults.starts_before_time {
-        params.push(("starts_before_time", starts_before_time));
-    }
-    if let Some(organizer) = &filters_with_defaults.organizer {
-        params.push(("organizer", organizer));
-    }
-    if let Some(sort_by) = &filters_with_defaults.sort_by {
-        params.push(("sort_by", sort_by));
-    }
-
-    let pagination_view = PaginationView::new(page_size, total_count, page, params);
-
-    // Limit results to page size
-    if event_views.len() > page_size as usize {
-        event_views.truncate(page_size as usize);
-    }
-
-    // Build context for template
-    Ok((
-        http::StatusCode::OK,
-        RenderHtml(
-            &render_template,
-            web_context.engine.clone(),
-            template_context! {
-                current_handle => auth.0,
-                language => language.to_string(),
-                canonical_url => format!("https://{}/events", web_context.config.external_base),
-                events => event_views,
-                pagination => pagination_view,
-                filters => filters_with_defaults,
-                total_count => total_count,
-            },
-        ),
-    )
-        .into_response())
-}