fix: Use proper handle validation for organizer display names

Replace hardcoded DID truncation with handle validation logic in EventView
creation. Fixes organizer names showing as "@did:plc:hjvw..." instead of
proper handles like "@saving-kit.pyroclastic.cloud" in event listings.

i18n/en-us/actions.ftl

···
 # Status options for events
 status-active = Active
 
-# Status options for RSVPs
-status-going = Going
-status-interested = Interested
-status-not-going = Not Going
-
-# Event modes
-
 # Location types
 location-type-venue = Venue
 location-type-coordinates = Coordinates

i18n/en-us/ui.ftl

···
 community-lexicon-calendar-event-status-postponed = Postponed
 community-lexicon-calendar-event-status-planned = Planned
 
+# User Status Labels (for RSVP and role indicators)
+status-organizer = Organizer
+status-legacy = Legacy
+status-going = Going
+status-interested = Interested
+status-not-going = Not Going
+status-unknown = Unknown
+
 # Distance and Location
 distance-km = {$distance} km away
 location-unknown = Location not specified

i18n/fr-ca/actions.ftl

···
 # Options de statut pour les événements
 status-active = Actif
 
-# Options de statut pour les RSVP
-status-going = J'y vais
-status-interested = Intéressé
-status-not-going = Je n'y vais pas
-
-# Modes d'événement
 
 # Types d'emplacement
 location-type-venue = Lieu

i18n/fr-ca/ui.ftl

···
 community-lexicon-calendar-event-status-postponed = Reporté
 community-lexicon-calendar-event-status-planned = Planifié
 
+# Étiquettes de statut utilisateur (pour les indicateurs de RSVP et de rôle)
+status-organizer = Organisateur
+status-legacy = Ancienne version
+status-going = Je participe
+status-interested = Intéressé
+status-not-going = Je n'y vais pas
+status-unknown = Inconnu
+
 # Distance et lieu
 distance-km = {$distance} km de distance
 location-unknown = Lieu non spécifié

src/filtering/facets.rs

···
         // Define date ranges to calculate
         let date_ranges = vec![
             ("today", "Today"),
-            ("this_week", "This Week"),
-            ("this_month", "This Month"),
-            ("next_week", "Next Week"),
-            ("next_month", "Next Month"),
+            ("this-week", "This Week"),
+            ("this-month", "This Month"),
+            ("next-week", "Next Week"),
+            ("next-month", "Next Month"),
         ];
         
         for (key, _label) in date_ranges {
···
         // Define date ranges to calculate
         let date_ranges = vec![
             ("today", "Today"),
-            ("this_week", "This Week"),
-            ("this_month", "This Month"),
-            ("next_week", "Next Week"),
-            ("next_month", "Next Month"),
+            ("this-week", "This Week"),
+            ("this-month", "This Month"),
+            ("next-week", "Next Week"),
+            ("next-month", "Next Month"),
         ];
         
         for (key, _label) in date_ranges {
···
                 let end = now.date_naive().and_hms_opt(23, 59, 59).unwrap().and_utc();
                 (start, end)
             }
-            "this_week" => {
+            "this_week" | "this-week" => {
                 let days_since_monday = now.weekday().num_days_from_monday();
                 let start = (now - chrono::Duration::days(days_since_monday as i64))
                     .date_naive().and_hms_opt(0, 0, 0).unwrap().and_utc();
                 let end = start + chrono::Duration::days(6);
                 (start, end)
             }
-            "this_month" => {
+            "this_month" | "this-month" => {
                 let start = now.date_naive().with_day(1).unwrap().and_hms_opt(0, 0, 0).unwrap().and_utc();
                 let end = if now.month() == 12 {
                     chrono::NaiveDate::from_ymd_opt(now.year() + 1, 1, 1).unwrap()
···
                 }.and_hms_opt(0, 0, 0).unwrap().and_utc();
                 (start, end)
             }
-            "next_week" => {
+            "next_week" | "next-week" => {
                 let days_until_next_monday = 7 - now.weekday().num_days_from_monday();
                 let start = (now + chrono::Duration::days(days_until_next_monday as i64))
                     .date_naive().and_hms_opt(0, 0, 0).unwrap().and_utc();
                 let end = start + chrono::Duration::days(6);
                 (start, end)
             }
-            "next_month" => {
+            "next_month" | "next-month" => {
                 let start = if now.month() == 12 {
                     chrono::NaiveDate::from_ymd_opt(now.year() + 1, 1, 1).unwrap()
                 } else {
···
     /// Generate i18n key for mode facets
     pub fn generate_mode_i18n_key(mode: &str) -> String {
         match mode {
-            "community.lexicon.calendar.event#inperson" => "mode-inperson".to_string(),
+            "community.lexicon.calendar.event#inperson" => "mode-in-person".to_string(),
             "community.lexicon.calendar.event#virtual" => "mode-virtual".to_string(),
             "community.lexicon.calendar.event#hybrid" => "mode-hybrid".to_string(),
             _ => format!("mode-{}", mode.to_lowercase().replace('#', "-").replace('.', "-")),
···
         }
     }
     
-    /// Get display name for mode facet value (locale-aware)
-    #[allow(dead_code)]
-    fn mode_display_name(mode: &str, locale: &LanguageIdentifier) -> String {
-        let lang_str = locale.language.as_str();
-        match mode {
-            "community.lexicon.calendar.event#inperson" => match lang_str {
-                "en" => "In-Person".to_string(),
-                "fr" => "En personne".to_string(),
-                _ => "In-Person".to_string(),
-            },
-            "community.lexicon.calendar.event#virtual" => match lang_str {
-                "en" => "Virtual".to_string(),
-                "fr" => "Virtuel".to_string(),
-                _ => "Virtual".to_string(),
-            },
-            "community.lexicon.calendar.event#hybrid" => match lang_str {
-                "en" => "Hybrid".to_string(),
-                "fr" => "Hybride".to_string(),
-                _ => "Hybrid".to_string(),
-            },
-            _ => mode.to_string(),
-        }
-    }
+
     
-    /// Get display name for status facet value (locale-aware)
-    #[allow(dead_code)]
-    fn status_display_name(status: &str, locale: &LanguageIdentifier) -> String {
-        let lang_str = locale.language.as_str();
-        match status {
-            "community.lexicon.calendar.event#scheduled" => match lang_str {
-                "en" => "Scheduled".to_string(),
-                "fr" => "Planifié".to_string(),
-                _ => "Scheduled".to_string(),
-            },
-            "community.lexicon.calendar.event#rescheduled" => match lang_str {
-                "en" => "Rescheduled".to_string(),
-                "fr" => "Reporté".to_string(),
-                _ => "Rescheduled".to_string(),
-            },
-            "community.lexicon.calendar.event#cancelled" => match lang_str {
-                "en" => "Cancelled".to_string(),
-                "fr" => "Annulé".to_string(),
-                _ => "Cancelled".to_string(),
-            },
-            "community.lexicon.calendar.event#postponed" => match lang_str {
-                "en" => "Postponed".to_string(),
-                "fr" => "Reporté".to_string(),
-                _ => "Postponed".to_string(),
-            },
-            "community.lexicon.calendar.event#planned" => match lang_str {
-                "en" => "Planned".to_string(),
-                "fr" => "Planifié".to_string(),
-                _ => "Planned".to_string(),
-            },
-            _ => status.to_string(),
-        }
-    }
+
     
-    /// Get display name for date range facet (locale-aware)
-    #[allow(dead_code)]
-    fn date_range_display_name(range_key: &str, locale: &LanguageIdentifier) -> String {
-        let lang_str = locale.language.as_str();
-        match range_key {
-            "today" => match lang_str {
-                "en" => "Today".to_string(),
-                "fr" => "Aujourd'hui".to_string(),
-                _ => "Today".to_string(),
-            },
-            "this_week" => match lang_str {
-                "en" => "This Week".to_string(),
-                "fr" => "Cette semaine".to_string(),
-                _ => "This Week".to_string(),
-            },
-            "this_month" => match lang_str {
-                "en" => "This Month".to_string(),
-                "fr" => "Ce mois".to_string(),
-                _ => "This Month".to_string(),
-            },
-            "next_week" => match lang_str {
-                "en" => "Next Week".to_string(),
-                "fr" => "La semaine prochaine".to_string(),
-                _ => "Next Week".to_string(),
-            },
-            "next_month" => match lang_str {
-                "en" => "Next Month".to_string(),
-                "fr" => "Le mois prochain".to_string(),
-                _ => "Next Month".to_string(),
-            },
-            _ => range_key.to_string(),
-        }
-    }
+
     
     /// Get translated facet name with fallback to formatted readable name
     pub fn get_translated_facet_name(&self, i18n_key: &str, locale: &LanguageIdentifier) -> String {
···
     fn test_generate_mode_i18n_key() {
         assert_eq!(
             FacetCalculator::generate_mode_i18n_key("community.lexicon.calendar.event#inperson"),
-            "mode-inperson"
+            "mode-in-person"
         );
         
         assert_eq!(

src/filtering/hydration.rs

···
                 format!("Failed to parse AT-URI: {}", event.aturi)
             ))?;
 
-        // Get organizer display name (fallback to DID prefix if not available)
-        let organizer_display_name = format!("did:{}...", &event.did[4..12]);
+        // Get organizer handle for URL generation
+        let organizer_handle = handle_for_did(&self.pool, &event.did).await
+            .map(|h| h.handle)
+            .unwrap_or_else(|_| event.did.clone());
+
+        // Generate the correct URL format: /{handle_slug}/{event_rkey}
+        let handle_slug = crate::http::utils::slug_from_handle(&organizer_handle);
+        let rkey = parsed_uri.2; // The rkey is the third component of the parsed AT-URI
+        let site_url = format!("/{}/{}", handle_slug, rkey);
+
+        // Get organizer display name using the same logic as in handle_filter_events.rs
+        let organizer_display_name = {
+            // Only use the handle if it looks like a proper handle (contains a dot and doesn't start with "did:")
+            if organizer_handle.contains('.') && !organizer_handle.starts_with("did:") {
+                organizer_handle.clone()
+            } else {
+                // Fallback to a shortened DID if no proper handle is available
+                if event.did.len() > 20 {
+                    format!("{}...", &event.did[..20])
+                } else {
+                    event.did.clone()
+                }
+            }
+        };
 
         let event_view = EventView {
-            site_url: "https://smokesignal.events".to_string(),
+            site_url,
             aturi: event.aturi.clone(),
             cid: event.cid.clone(),
             repository: parsed_uri.0,

src/filtering/i18n_integration_test.rs

···
     fn test_i18n_translation_functions() {
         // Test mode key generation
         let mode_key = FacetCalculator::generate_mode_i18n_key("community.lexicon.calendar.event#inperson");
-        assert_eq!(mode_key, "mode-inperson");
+        assert_eq!(mode_key, "mode-in-person");
         
         println!("Mode i18n key generation test:");
         println!("  inperson -> {}", mode_key);
···
         // Test the i18n key generation functions
         assert_eq!(
             FacetCalculator::generate_mode_i18n_key("community.lexicon.calendar.event#inperson"),
-            "mode-inperson"
+            "mode-in-person"
         );
         
         assert_eq!(

src/http/handle_filter_events.rs

···
         }),
         
         organizer_did: event.did.clone(),
-        organizer_display_name: hydrated.creator_handle
-            .as_ref()
-            .map(|h| h.handle.clone())
-            .unwrap_or_else(|| event.did.clone()),
+        organizer_display_name: {
+            let display_name = hydrated.creator_handle
+                .as_ref()
+                .and_then(|h| {
+                    // Log what we received for debugging
+                    tracing::debug!("Handle for DID {}: '{}'", event.did, h.handle);
+                    
+                    // Only use the handle if it looks like a proper handle (contains a dot and doesn't start with "did:")
+                    if h.handle.contains('.') && !h.handle.starts_with("did:") {
+                        Some(h.handle.clone())
+                    } else {
+                        tracing::debug!("Rejecting handle '{}' as it doesn't look like a proper handle", h.handle);
+                        None
+                    }
+                })
+                .unwrap_or_else(|| {
+                    // Fallback to a shortened DID if no proper handle is available
+                    tracing::debug!("Using fallback display name for DID: {}", event.did);
+                    if event.did.len() > 20 {
+                        format!("{}...", &event.did[..20])
+                    } else {
+                        event.did.clone()
+                    }
+                });
+            
+            tracing::debug!("Final organizer_display_name for DID {}: '{}'", event.did, display_name);
+            display_name
+        },
         
         starts_at_machine: event_details.starts_at.as_ref().map(|dt| dt.to_rfc3339()),
         starts_at_human: event_details.starts_at.as_ref().map(|dt| {

src/http/utils.rs

···
     }
     ret.to_string()
 }
+
+/// Convert a handle to a URL-safe slug format
+///
+/// This function takes a handle (which may be in various formats like `example.com`,
+/// `@example.com`, `did:web:example.com`, or `did:plc:abc123`) and converts it to
+/// a URL-safe slug that can be used in URL paths.
+///
+/// # Arguments
+/// * `handle` - The handle to convert to a slug
+///
+/// # Returns
+/// * A URL-safe slug string
+pub fn slug_from_handle(handle: &str) -> String {
+    // Strip common prefixes to get the core handle
+    let trimmed = if let Some(value) = handle.strip_prefix("at://") {
+        value
+    } else if let Some(value) = handle.strip_prefix('@') {
+        value
+    } else {
+        handle
+    };
+
+    // For DID formats, we need to handle them specially
+    if let Some(web_handle) = trimmed.strip_prefix("did:web:") {
+        // For did:web: format, use the domain part
+        web_handle.to_string()
+    } else if trimmed.starts_with("did:plc:") {
+        // For did:plc: format, use the full DID as the slug
+        trimmed.to_string()
+    } else {
+        // For regular handles, use as-is (they're already domain-like)
+        trimmed.to_string()
+    }
+}