Add analytics drill-down, visitor logs, exports and pagination

src/db/analytics.rs

@@ -508,6 +508,227 @@ pub fn get_metric_rankings_raw(
     Ok(res)
 }
 
+/// Returns the raw visit counts for a specific target ID.
+pub fn get_target_visit_count(
+    conn: &Connection,
+    target_type: &str,
+    target_id: &str,
+) -> rusqlite::Result<i64> {
+    conn.query_row(
+        "SELECT COUNT(*) FROM visits WHERE target_type = ?1 AND target_id = ?2;",
+        params![target_type, target_id],
+        |row| row.get(0),
+    )
+}
+
+/// Returns the distinct IP count (Unique Visitors) for a specific target ID.
+pub fn get_target_unique_visitors(
+    conn: &Connection,
+    target_type: &str,
+    target_id: &str,
+) -> rusqlite::Result<i64> {
+    conn.query_row(
+        "SELECT COUNT(DISTINCT ip_address) FROM visits WHERE target_type = ?1 AND target_id = ?2;",
+        params![target_type, target_id],
+        |row| row.get(0),
+    )
+}
+
+/// Fetches the monthly clicks trend for a specific target ID, falling back to a raw visits query if monthly_summaries are empty.
+pub fn get_monthly_clicks_trend(
+    conn: &Connection,
+    target_type: &str,
+    target_id: &str,
+    limit_months: i64,
+) -> rusqlite::Result<Vec<(String, i64)>> {
+    let mut stmt = conn.prepare(
+        "SELECT year_month, SUM(metric_value) FROM monthly_summaries
+         WHERE target_type = ?1 AND target_id = ?2 AND metric_type = 'clicks'
+         GROUP BY year_month ORDER BY year_month ASC LIMIT ?3;"
+    )?;
+    let rows = stmt.query_map(params![target_type, target_id, limit_months], |row| {
+        Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
+    })?;
+    let mut res = Vec::new();
+    for r in rows {
+        res.push(r?);
+    }
+
+    if res.is_empty() {
+        // Fallback to raw visits
+        let mut stmt = conn.prepare(
+            "SELECT strftime('%Y-%m', timestamp) as m, COUNT(*) FROM visits
+             WHERE target_type = ?1 AND target_id = ?2
+             GROUP BY m ORDER BY m ASC LIMIT ?3;"
+        )?;
+        let rows = stmt.query_map(params![target_type, target_id, limit_months], |row| {
+            Ok((row.get::<_, String>(0)?, row.get::<_, i64>(1)?))
+        })?;
+        for r in rows {
+            res.push(r?);
+        }
+    }
+
+    Ok(res)
+}
+
+pub fn get_visits_schema_columns(conn: &Connection) -> rusqlite::Result<std::collections::HashSet<String>> {
+    let mut columns = std::collections::HashSet::new();
+    let mut stmt = conn.prepare("PRAGMA table_info(visits);")?;
+    let mut rows = stmt.query([])?;
+    while let Some(row) = rows.next()? {
+        let name: String = row.get("name")?;
+        columns.insert(name);
+    }
+    Ok(columns)
+}
+
+pub fn get_target_visits_paginated(
+    conn: &Connection,
+    target_type: &str,
+    target_id: &str,
+    limit: i64,
+    offset: i64,
+    date_from: Option<&str>,
+    date_to: Option<&str>,
+) -> rusqlite::Result<Vec<VisitRecord>> {
+    let mut sql = "SELECT id, target_type, target_id, timestamp, ip_address, user_agent, referer, accept_language, country, status_code FROM visits WHERE target_type = ?1 AND target_id = ?2".to_string();
+    let mut params: Vec<Box<dyn rusqlite::ToSql>> = vec![
+        Box::new(target_type.to_string()),
+        Box::new(target_id.to_string()),
+    ];
+
+    if let Some(df) = date_from {
+        sql.push_str(&format!(" AND timestamp >= ?{}", params.len() + 1));
+        params.push(Box::new(format!("{}T00:00:00Z", df)));
+    }
+
+    if let Some(dt) = date_to {
+        if let Ok(parsed_date) = chrono::NaiveDate::parse_from_str(dt, "%Y-%m-%d") {
+            let next_day = parsed_date + chrono::Duration::days(1);
+            sql.push_str(&format!(" AND timestamp < ?{}", params.len() + 1));
+            params.push(Box::new(format!("{}T00:00:00Z", next_day.format("%Y-%m-%d"))));
+        }
+    }
+
+    sql.push_str(" ORDER BY timestamp DESC, id DESC LIMIT ?");
+    sql.push_str(&(params.len() + 1).to_string());
+    params.push(Box::new(limit));
+
+    sql.push_str(" OFFSET ?");
+    sql.push_str(&(params.len() + 1).to_string());
+    params.push(Box::new(offset));
+
+    let mut stmt = conn.prepare(&sql)?;
+    let param_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect();
+    let rows = stmt.query_map(rusqlite::params_from_iter(param_refs), |row| {
+        Ok(VisitRecord {
+            id: row.get("id")?,
+            target_type: row.get("target_type")?,
+            target_id: row.get("target_id")?,
+            timestamp: row.get("timestamp")?,
+            ip_address: row.get("ip_address")?,
+            user_agent: row.get("user_agent")?,
+            referer: row.get("referer")?,
+            accept_language: row.get("accept_language")?,
+            country: row.get("country")?,
+            status_code: row.get("status_code")?,
+        })
+    })?;
+
+    let mut visits = Vec::new();
+    for r in rows {
+        visits.push(r?);
+    }
+    Ok(visits)
+}
+
+pub fn get_target_visits_all_in_memory(
+    conn: &Connection,
+    target_type: &str,
+    target_id: &str,
+    date_from: Option<&str>,
+    date_to: Option<&str>,
+) -> rusqlite::Result<Vec<VisitRecord>> {
+    let mut sql = "SELECT id, target_type, target_id, timestamp, ip_address, user_agent, referer, accept_language, country, status_code FROM visits WHERE target_type = ?1 AND target_id = ?2".to_string();
+    let mut params: Vec<Box<dyn rusqlite::ToSql>> = vec![
+        Box::new(target_type.to_string()),
+        Box::new(target_id.to_string()),
+    ];
+
+    if let Some(df) = date_from {
+        sql.push_str(&format!(" AND timestamp >= ?{}", params.len() + 1));
+        params.push(Box::new(format!("{}T00:00:00Z", df)));
+    }
+
+    if let Some(dt) = date_to {
+        if let Ok(parsed_date) = chrono::NaiveDate::parse_from_str(dt, "%Y-%m-%d") {
+            let next_day = parsed_date + chrono::Duration::days(1);
+            sql.push_str(&format!(" AND timestamp < ?{}", params.len() + 1));
+            params.push(Box::new(format!("{}T00:00:00Z", next_day.format("%Y-%m-%d"))));
+        }
+    }
+
+    sql.push_str(" ORDER BY timestamp DESC, id DESC");
+
+    let mut stmt = conn.prepare(&sql)?;
+    let param_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect();
+    let rows = stmt.query_map(rusqlite::params_from_iter(param_refs), |row| {
+        Ok(VisitRecord {
+            id: row.get("id")?,
+            target_type: row.get("target_type")?,
+            target_id: row.get("target_id")?,
+            timestamp: row.get("timestamp")?,
+            ip_address: row.get("ip_address")?,
+            user_agent: row.get("user_agent")?,
+            referer: row.get("referer")?,
+            accept_language: row.get("accept_language")?,
+            country: row.get("country")?,
+            status_code: row.get("status_code")?,
+        })
+    })?;
+
+    let mut visits = Vec::new();
+    for r in rows {
+        visits.push(r?);
+    }
+    Ok(visits)
+}
+
+pub fn get_target_visit_total_filtered(
+    conn: &Connection,
+    target_type: &str,
+    target_id: &str,
+    date_from: Option<&str>,
+    date_to: Option<&str>,
+) -> rusqlite::Result<i64> {
+    if date_from.is_none() && date_to.is_none() {
+        return get_target_visit_count(conn, target_type, target_id);
+    }
+
+    let mut sql = "SELECT COUNT(*) FROM visits WHERE target_type = ?1 AND target_id = ?2".to_string();
+    let mut params: Vec<Box<dyn rusqlite::ToSql>> = vec![
+        Box::new(target_type.to_string()),
+        Box::new(target_id.to_string()),
+    ];
+
+    if let Some(df) = date_from {
+        sql.push_str(&format!(" AND timestamp >= ?{}", params.len() + 1));
+        params.push(Box::new(format!("{}T00:00:00Z", df)));
+    }
+
+    if let Some(dt) = date_to {
+        if let Ok(parsed_date) = chrono::NaiveDate::parse_from_str(dt, "%Y-%m-%d") {
+            let next_day = parsed_date + chrono::Duration::days(1);
+            sql.push_str(&format!(" AND timestamp < ?{}", params.len() + 1));
+            params.push(Box::new(format!("{}T00:00:00Z", next_day.format("%Y-%m-%d"))));
+        }
+    }
+
+    let param_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect();
+    conn.query_row(&sql, rusqlite::params_from_iter(param_refs), |row| row.get(0))
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

src/db/content.rs

@@ -47,6 +47,19 @@ pub fn get_tags_for_url(conn: &Connection, url_id: &str) -> rusqlite::Result<Vec
     Ok(tags)
 }
 
+/// Get the total count of URLs associated with a specific tag name.
+pub fn get_url_count_by_tag(conn: &Connection, tag: &str) -> rusqlite::Result<i64> {
+    let tag_name = tag.trim().to_lowercase();
+    conn.query_row(
+        "SELECT COUNT(*) FROM urls u
+         JOIN url_tags ut ON u.id = ut.url_id
+         JOIN tags t ON ut.tag_id = t.id
+         WHERE t.name = ?1;",
+        params![tag_name],
+        |row| row.get(0),
+    )
+}
+
 /// The full column list used in all URL SELECT queries.
 const URL_COLUMNS: &str = "id, code, destination, title, description, status, created_at, updated_at, expires_at, expired, password_hash, last_status, last_latency_ms, max_access_count, access_count";
 

src/templates/analytics.rs

@@ -0,0 +1,108 @@
+use crate::models::{LandingPage, Url};
+use askama::Template;
+use axum::{
+    http::StatusCode,
+    response::{Html, IntoResponse, Response},
+};
+
+#[derive(Clone, Debug)]
+pub struct VisitorLogEntry {
+    pub sr: usize,
+    pub timestamp: String,
+    pub ip_address: String,
+    pub country: String,
+    pub referrer: String,
+    pub browser: String,
+    pub user_agent: String,
+    pub utm_source: String,
+    pub utm_campaign: String,
+}
+
+#[derive(Template)]
+#[template(path = "url_analytics.html")]
+pub struct UrlAnalyticsTemplate {
+    pub admin_username: String,
+    pub url: Url,
+    pub total_clicks: i64,
+    pub unique_visitors: i64,
+    pub qr_scans: i64,
+    pub direct_clicks: i64,
+    pub traffic_chart: String,
+    pub monthly_chart: String,
+    pub countries_chart: String,
+    pub referrers_chart: String,
+    pub browsers_chart: String,
+    // Paginated visitor logs
+    pub visits: Vec<VisitorLogEntry>,
+    pub current_page: usize,
+    pub total_pages: usize,
+    pub visible_pages: Vec<usize>,
+    pub total_records: i64,
+    pub page_start: usize,
+    pub page_end: usize,
+    pub date_from: Option<String>,
+    pub date_to: Option<String>,
+}
+
+impl UrlAnalyticsTemplate {
+    pub fn is_current(&self, page: &usize) -> bool {
+        *page == self.current_page
+    }
+}
+
+
+impl IntoResponse for UrlAnalyticsTemplate {
+    fn into_response(self) -> Response {
+        match self.render() {
+            Ok(html) => Html(html).into_response(),
+            Err(e) => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Render error: {}", e),
+            )
+                .into_response(),
+        }
+    }
+}
+
+#[derive(Template)]
+#[template(path = "page_analytics.html")]
+pub struct PageAnalyticsTemplate {
+    pub admin_username: String,
+    pub page: LandingPage,
+    pub total_views: i64,
+    pub unique_visitors: i64,
+    pub traffic_chart: String,
+    pub monthly_chart: String,
+    pub countries_chart: String,
+    pub referrers_chart: String,
+    // Paginated visitor logs
+    pub visits: Vec<VisitorLogEntry>,
+    pub current_page: usize,
+    pub total_pages: usize,
+    pub visible_pages: Vec<usize>,
+    pub total_records: i64,
+    pub page_start: usize,
+    pub page_end: usize,
+    pub date_from: Option<String>,
+    pub date_to: Option<String>,
+}
+
+impl PageAnalyticsTemplate {
+    pub fn is_current(&self, page: &usize) -> bool {
+        *page == self.current_page
+    }
+}
+
+
+impl IntoResponse for PageAnalyticsTemplate {
+    fn into_response(self) -> Response {
+        match self.render() {
+            Ok(html) => Html(html).into_response(),
+            Err(e) => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                format!("Render error: {}", e),
+            )
+                .into_response(),
+        }
+    }
+}

src/templates/mod.rs

@@ -1,9 +1,11 @@
+pub mod analytics;
 pub mod dashboard;
 pub mod pages;
 pub mod settings;
 pub mod stats;
 pub mod urls;
 
+pub use analytics::{PageAnalyticsTemplate, UrlAnalyticsTemplate, VisitorLogEntry};
 pub use dashboard::DashboardTemplate;
 pub use pages::PagesTemplate;
 pub use settings::SettingsTemplate;

src/templates/pages.rs

@@ -12,8 +12,18 @@ pub struct PagesTemplate {
     pub pages: Vec<LandingPage>,
     pub csrf_token: String,
     pub error: Option<String>,
+    pub current_page: usize,
+    pub total_pages: usize,
+    pub visible_pages: Vec<usize>,
 }
 
+impl PagesTemplate {
+    pub fn is_current(&self, page: &usize) -> bool {
+        *page == self.current_page
+    }
+}
+
+
 impl IntoResponse for PagesTemplate {
     fn into_response(self) -> Response {
         match self.render() {

src/templates/urls.rs

@@ -14,8 +14,18 @@ pub struct UrlsTemplate {
     pub error: Option<String>,
     pub tag_filter: Option<String>,
     pub base_url: String,
+    pub current_page: usize,
+    pub total_pages: usize,
+    pub visible_pages: Vec<usize>,
 }
 
+impl UrlsTemplate {
+    pub fn is_current(&self, page: &usize) -> bool {
+        *page == self.current_page
+    }
+}
+
+
 impl IntoResponse for UrlsTemplate {
     fn into_response(self) -> Response {
         match self.render() {

src/web/admin.rs

@@ -63,16 +63,23 @@ use crate::auth::{
 use crate::charts::{generate_bar_chart, generate_line_chart};
 use crate::db::analytics::{
     get_clicks_trend, get_clicks_trend_raw, get_metric_rankings, get_metric_rankings_raw,
-    get_total_clicks,
+    get_total_clicks, get_target_unique_visitors, get_monthly_clicks_trend,
+    get_visits_schema_columns, get_target_visits_paginated, get_target_visits_all_in_memory,
+    get_target_visit_total_filtered, parse_ua, clean_referrer,
 };
 use crate::db::content::{
     create_landing_page, delete_landing_page, delete_url, get_landing_page_count, get_url_counts,
-    list_landing_pages, list_urls,
+    list_landing_pages, list_urls, get_url_count_by_tag, get_url_by_id, get_landing_page_by_id,
 };
 use crate::models::User;
 use crate::state::AppState;
 use crate::utils::{get_client_ip, get_db_file_info, get_memory_usage};
 
+const PAGE_SIZE: usize = 25;
+const ANALYTICS_PAGE_SIZE: usize = 50;
+const MAX_JSON_EXPORT_ROWS: usize = 50_000;
+
+
 // Helper: Verify session and return user or redirect to login
 async fn require_auth(state: &AppState, jar: &CookieJar) -> Result<(User, String), Redirect> {
     let conn = state.admin_db.lock().unwrap();
@@ -353,6 +360,7 @@ pub async fn dashboard_get(State(state): State<AppState>, jar: CookieJar) -> Res
 pub struct UrlsQuery {
     pub tag: Option<String>,
     pub error: Option<String>,
+    pub page: Option<usize>,
 }
 
 pub async fn urls_get(
@@ -365,9 +373,26 @@ pub async fn urls_get(
         Err(redir) => return redir.into_response(),
     };
 
-    let urls = {
+    let (urls, total_pages, page, visible_pages) = {
         let conn = state.content_db.lock().unwrap();
-        list_urls(&conn, 100, 0, query.tag.as_deref()).unwrap_or_default()
+        let total_records = if let Some(tag_str) = query.tag.as_deref() {
+            get_url_count_by_tag(&conn, tag_str).unwrap_or(0)
+        } else {
+            get_url_counts(&conn).map(|(t, _, _)| t).unwrap_or(0)
+        };
+        let calculated_total_pages = (total_records as usize).div_ceil(PAGE_SIZE);
+        let total_pages = std::cmp::max(1, calculated_total_pages);
+        let requested_page = query.page.unwrap_or(1);
+        let current_page = if requested_page == 0 { 1 } else { requested_page }.clamp(1, total_pages);
+        let offset = (current_page - 1) * PAGE_SIZE;
+
+        let urls = list_urls(&conn, PAGE_SIZE as i64, offset as i64, query.tag.as_deref()).unwrap_or_default();
+        
+        let start_page = current_page.saturating_sub(3).max(1);
+        let end_page = std::cmp::min(total_pages, current_page + 3);
+        let visible_pages: Vec<usize> = (start_page..=end_page).collect();
+
+        (urls, total_pages, current_page, visible_pages)
     };
 
     let csrf_token = generate_csrf_token(&session_id);
@@ -390,11 +415,15 @@ pub async fn urls_get(
         error: query.error,
         tag_filter: query.tag,
         base_url,
+        current_page: page,
+        total_pages,
+        visible_pages,
     };
 
     template.into_response()
 }
 
+
 #[derive(Deserialize)]
 pub struct CreateUrlForm {
     pub destination: String,
@@ -613,6 +642,7 @@ pub async fn urls_delete(
 #[derive(Deserialize)]
 pub struct PagesQuery {
     pub error: Option<String>,
+    pub page: Option<usize>,
 }
 
 pub async fn pages_get(
@@ -625,9 +655,22 @@ pub async fn pages_get(
         Err(redir) => return redir.into_response(),
     };
 
-    let pages = {
+    let (pages, total_pages, page, visible_pages) = {
         let conn = state.content_db.lock().unwrap();
-        list_landing_pages(&conn, 100, 0).unwrap_or_default()
+        let total_records = get_landing_page_count(&conn).unwrap_or(0);
+        let calculated_total_pages = (total_records as usize).div_ceil(PAGE_SIZE);
+        let total_pages = std::cmp::max(1, calculated_total_pages);
+        let requested_page = query.page.unwrap_or(1);
+        let current_page = if requested_page == 0 { 1 } else { requested_page }.clamp(1, total_pages);
+        let offset = (current_page - 1) * PAGE_SIZE;
+
+        let pages = list_landing_pages(&conn, PAGE_SIZE as i64, offset as i64).unwrap_or_default();
+        
+        let start_page = current_page.saturating_sub(3).max(1);
+        let end_page = std::cmp::min(total_pages, current_page + 3);
+        let visible_pages: Vec<usize> = (start_page..=end_page).collect();
+
+        (pages, total_pages, current_page, visible_pages)
     };
 
     let csrf_token = generate_csrf_token(&session_id);
@@ -637,6 +680,9 @@ pub async fn pages_get(
         pages,
         csrf_token,
         error: query.error,
+        current_page: page,
+        total_pages,
+        visible_pages,
     };
 
     template.into_response()
@@ -1538,3 +1584,694 @@ pub async fn restore_backup_post(
         }
     }
 }
+
+#[derive(Deserialize)]
+pub struct AnalyticsQuery {
+    pub analytics_page: Option<usize>,
+    pub date_from: Option<String>,
+    pub date_to: Option<String>,
+}
+
+fn validate_date_filters(date_from: Option<&str>, date_to: Option<&str>) -> Result<(Option<String>, Option<String>), StatusCode> {
+    let from_parsed = match date_from {
+        Some(df) if !df.is_empty() => {
+            match chrono::NaiveDate::parse_from_str(df, "%Y-%m-%d") {
+                Ok(d) => Some(d),
+                Err(_) => return Err(StatusCode::BAD_REQUEST),
+            }
+        }
+        _ => None,
+    };
+    let to_parsed = match date_to {
+        Some(dt) if !dt.is_empty() => {
+            match chrono::NaiveDate::parse_from_str(dt, "%Y-%m-%d") {
+                Ok(d) => Some(d),
+                Err(_) => return Err(StatusCode::BAD_REQUEST),
+            }
+        }
+        _ => None,
+    };
+    if let (Some(f), Some(t)) = (from_parsed, to_parsed) {
+        if f > t {
+            return Err(StatusCode::BAD_REQUEST);
+        }
+    }
+    Ok((
+        from_parsed.map(|d| d.format("%Y-%m-%d").to_string()),
+        to_parsed.map(|d| d.format("%Y-%m-%d").to_string()),
+    ))
+}
+
+fn escape_csv_field(field: &str) -> String {
+    let needs_escaping = field.contains(',')
+        || field.contains('"')
+        || field.contains('\n')
+        || field.contains('\r');
+    if needs_escaping {
+        let escaped = field.replace('"', "\"\"");
+        format!("\"{}\"", escaped)
+    } else {
+        field.to_string()
+    }
+}
+
+struct DbExportStream {
+    receiver: tokio::sync::mpsc::Receiver<Result<axum::body::Bytes, std::convert::Infallible>>,
+}
+
+impl futures_util::stream::Stream for DbExportStream {
+    type Item = Result<axum::body::Bytes, std::convert::Infallible>;
+
+    fn poll_next(
+        mut self: std::pin::Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        self.receiver.poll_recv(cx)
+    }
+}
+
+async fn perform_csv_export(
+    state: AppState,
+    target_type: &'static str,
+    id: String,
+    date_from: Option<String>,
+    date_to: Option<String>,
+) -> Response {
+    let (clean_date_from, clean_date_to) = match validate_date_filters(
+        date_from.as_deref(),
+        date_to.as_deref(),
+    ) {
+        Ok(res) => res,
+        Err(status) => return status.into_response(),
+    };
+
+    let target_exists = {
+        let conn = state.content_db.lock().unwrap();
+        if target_type == "url" {
+            get_url_by_id(&conn, &id).map(|u| u.is_some()).unwrap_or(false)
+        } else {
+            get_landing_page_by_id(&conn, &id).map(|p| p.is_some()).unwrap_or(false)
+        }
+    };
+    if !target_exists {
+        return (StatusCode::NOT_FOUND, "Target not found").into_response();
+    }
+
+    let count = {
+        let conn = state.analytics_db.lock().unwrap();
+        get_target_visit_total_filtered(
+            &conn,
+            target_type,
+            &id,
+            clean_date_from.as_deref(),
+            clean_date_to.as_deref(),
+        ).unwrap_or(0)
+    };
+
+    let (has_utm_source, has_utm_campaign) = {
+        let conn = state.analytics_db.lock().unwrap();
+        let cols = get_visits_schema_columns(&conn).unwrap_or_default();
+        (cols.contains("utm_source"), cols.contains("utm_campaign"))
+    };
+
+    let (tx, rx) = tokio::sync::mpsc::channel::<Result<axum::body::Bytes, std::convert::Infallible>>(32);
+    let analytics_db = state.analytics_db.clone();
+    let target_id = id.clone();
+
+    tokio::task::spawn_blocking(move || {
+        let conn = analytics_db.lock().unwrap();
+        
+        let mut header = "Timestamp,IP Address,Country,Referrer,Browser,User-Agent".to_string();
+        if has_utm_source {
+            header.push_str(",UTM Source");
+        }
+        if has_utm_campaign {
+            header.push_str(",UTM Campaign");
+        }
+        header.push('\n');
+        
+        if tx.blocking_send(Ok(axum::body::Bytes::from(header))).is_err() {
+            return;
+        }
+
+        let select_fields = if has_utm_source && has_utm_campaign {
+            "timestamp, ip_address, country, referer, user_agent, utm_source, utm_campaign"
+        } else if has_utm_source {
+            "timestamp, ip_address, country, referer, user_agent, utm_source"
+        } else if has_utm_campaign {
+            "timestamp, ip_address, country, referer, user_agent, utm_campaign"
+        } else {
+            "timestamp, ip_address, country, referer, user_agent"
+        };
+
+        let mut sql = format!("SELECT {} FROM visits WHERE target_type = ?1 AND target_id = ?2", select_fields);
+        let mut params: Vec<Box<dyn rusqlite::ToSql>> = vec![
+            Box::new(target_type.to_string()),
+            Box::new(target_id),
+        ];
+
+        if let Some(df) = clean_date_from.as_deref() {
+            sql.push_str(&format!(" AND timestamp >= ?{}", params.len() + 1));
+            params.push(Box::new(format!("{}T00:00:00Z", df)));
+        }
+
+        if let Some(dt) = clean_date_to.as_deref() {
+            if let Ok(parsed_date) = chrono::NaiveDate::parse_from_str(dt, "%Y-%m-%d") {
+                let next_day = parsed_date + chrono::Duration::days(1);
+                sql.push_str(&format!(" AND timestamp < ?{}", params.len() + 1));
+                params.push(Box::new(format!("{}T00:00:00Z", next_day.format("%Y-%m-%d"))));
+            }
+        }
+
+        sql.push_str(" ORDER BY timestamp DESC, id DESC");
+
+        let mut stmt = match conn.prepare(&sql) {
+            Ok(s) => s,
+            Err(_) => return,
+        };
+
+        let param_refs: Vec<&dyn rusqlite::ToSql> = params.iter().map(|p| p.as_ref()).collect();
+        let mut rows = match stmt.query(rusqlite::params_from_iter(param_refs)) {
+            Ok(r) => r,
+            Err(_) => return,
+        };
+
+        let mut csv_buffer = String::new();
+
+        while let Ok(Some(row)) = rows.next() {
+            let timestamp: String = row.get(0).unwrap_or_default();
+            let ip_address: String = row.get(1).unwrap_or_default();
+            let country: String = row.get(2).unwrap_or_default();
+            let referer: String = row.get(3).unwrap_or_default();
+            let user_agent: String = row.get(4).unwrap_or_default();
+
+            let (browser, _, _) = parse_ua(&user_agent);
+            let referrer = clean_referrer(&referer);
+            let country_display = if country.is_empty() { "Unknown".to_string() } else { country };
+
+            let mut line = format!(
+                "{},{},{},{},{},{}",
+                escape_csv_field(&timestamp),
+                escape_csv_field(&ip_address),
+                escape_csv_field(&country_display),
+                escape_csv_field(&referrer),
+                escape_csv_field(&browser),
+                escape_csv_field(&user_agent)
+            );
+
+            let mut col_idx = 5;
+            if has_utm_source {
+                let utm_src: String = row.get(col_idx).unwrap_or_default();
+                line.push_str(&format!(",{}", escape_csv_field(&utm_src)));
+                col_idx += 1;
+            }
+            if has_utm_campaign {
+                let utm_camp: String = row.get(col_idx).unwrap_or_default();
+                line.push_str(&format!(",{}", escape_csv_field(&utm_camp)));
+            }
+            line.push('\n');
+
+            csv_buffer.push_str(&line);
+            if csv_buffer.len() >= 8192 {
+                let bytes = axum::body::Bytes::from(csv_buffer);
+                if tx.blocking_send(Ok(bytes)).is_err() {
+                    return;
+                }
+                csv_buffer = String::new();
+            }
+        }
+
+        if !csv_buffer.is_empty() {
+            let _ = tx.blocking_send(Ok(axum::body::Bytes::from(csv_buffer)));
+        }
+    });
+
+    let stream = DbExportStream { receiver: rx };
+    let filename = if target_type == "url" {
+        format!("url_{}_analytics.csv", id)
+    } else {
+        format!("page_{}_analytics.csv", id)
+    };
+
+    (
+        StatusCode::OK,
+        [
+            ("Content-Type", "text/csv"),
+            ("Content-Disposition", &format!("attachment; filename=\"{}\"", filename)),
+            ("X-BZOD-Export-Records", &count.to_string()),
+        ],
+        axum::body::Body::from_stream(stream),
+    ).into_response()
+}
+
+async fn perform_json_export(
+    state: AppState,
+    target_type: &'static str,
+    id: String,
+    date_from: Option<String>,
+    date_to: Option<String>,
+) -> Response {
+    let (clean_date_from, clean_date_to) = match validate_date_filters(
+        date_from.as_deref(),
+        date_to.as_deref(),
+    ) {
+        Ok(res) => res,
+        Err(status) => return status.into_response(),
+    };
+
+    let target_exists = {
+        let conn = state.content_db.lock().unwrap();
+        if target_type == "url" {
+            get_url_by_id(&conn, &id).map(|u| u.is_some()).unwrap_or(false)
+        } else {
+            get_landing_page_by_id(&conn, &id).map(|p| p.is_some()).unwrap_or(false)
+        }
+    };
+    if !target_exists {
+        return (StatusCode::NOT_FOUND, "Target not found").into_response();
+    }
+
+    let count = {
+        let conn = state.analytics_db.lock().unwrap();
+        get_target_visit_total_filtered(
+            &conn,
+            target_type,
+            &id,
+            clean_date_from.as_deref(),
+            clean_date_to.as_deref(),
+        ).unwrap_or(0)
+    };
+
+    if count > MAX_JSON_EXPORT_ROWS as i64 {
+        return StatusCode::PAYLOAD_TOO_LARGE.into_response();
+    }
+
+    let visits_raw = {
+        let conn = state.analytics_db.lock().unwrap();
+        match get_target_visits_all_in_memory(
+            &conn,
+            target_type,
+            &id,
+            clean_date_from.as_deref(),
+            clean_date_to.as_deref(),
+        ) {
+            Ok(v) => v,
+            Err(_) => return (StatusCode::INTERNAL_SERVER_ERROR, "Database error").into_response(),
+        }
+    };
+
+    #[derive(serde::Serialize)]
+    struct JsonExportRow {
+        timestamp: String,
+        ip_address: String,
+        country: String,
+        referrer: String,
+        browser: String,
+        user_agent: String,
+    }
+
+    let export_rows: Vec<JsonExportRow> = visits_raw
+        .into_iter()
+        .map(|r| {
+            let (browser, _, _) = parse_ua(&r.user_agent);
+            let referrer = clean_referrer(&r.referer);
+            let country_display = if r.country.is_empty() { "Unknown".to_string() } else { r.country };
+            JsonExportRow {
+                timestamp: r.timestamp,
+                ip_address: r.ip_address,
+                country: country_display,
+                referrer,
+                browser,
+                user_agent: r.user_agent,
+            }
+        })
+        .collect();
+
+    let body_str = match serde_json::to_string(&export_rows) {
+        Ok(s) => s,
+        Err(_) => return (StatusCode::INTERNAL_SERVER_ERROR, "Serialization error").into_response(),
+    };
+
+    let filename = if target_type == "url" {
+        format!("url_{}_analytics.json", id)
+    } else {
+        format!("page_{}_analytics.json", id)
+    };
+
+    (
+        StatusCode::OK,
+        [
+            ("Content-Type", "application/json"),
+            ("Content-Disposition", &format!("attachment; filename=\"{}\"", filename)),
+            ("X-BZOD-Export-Records", &count.to_string()),
+        ],
+        body_str,
+    ).into_response()
+}
+
+// GET /admin/analytics/url/:id
+pub async fn url_analytics_get(
+    State(state): State<AppState>,
+    jar: CookieJar,
+    Path(id): Path<String>,
+    Query(query): Query<AnalyticsQuery>,
+) -> Response {
+    let (user, _) = match require_auth(&state, &jar).await {
+        Ok(u) => u,
+        Err(redir) => return redir.into_response(),
+    };
+
+    let url = {
+        let conn = state.content_db.lock().unwrap();
+        match get_url_by_id(&conn, &id) {
+            Ok(Some(u)) => u,
+            Ok(None) => return (StatusCode::NOT_FOUND, "URL not found").into_response(),
+            Err(_) => return (StatusCode::INTERNAL_SERVER_ERROR, "Database error").into_response(),
+        }
+    };
+
+    let conn = state.analytics_db.lock().unwrap();
+
+    let schema_cols = get_visits_schema_columns(&conn).unwrap_or_default();
+    let has_utm_source = schema_cols.contains("utm_source");
+    let has_utm_campaign = schema_cols.contains("utm_campaign");
+    if has_utm_source || has_utm_campaign {
+        return (StatusCode::INTERNAL_SERVER_ERROR, "UTM mapping verification failed").into_response();
+    }
+
+    let (clean_date_from, clean_date_to) = match validate_date_filters(
+        query.date_from.as_deref(),
+        query.date_to.as_deref(),
+    ) {
+        Ok(res) => res,
+        Err(status) => return status.into_response(),
+    };
+
+    let total_clicks = get_target_visit_total_filtered(
+        &conn,
+        "url",
+        &id,
+        clean_date_from.as_deref(),
+        clean_date_to.as_deref(),
+    ).unwrap_or(0);
+
+    let unique_visitors = get_target_unique_visitors(&conn, "url", &id).unwrap_or(0);
+    let qr_scans = crate::db::qr::get_qr_scan_count(&conn, &id).unwrap_or(0);
+    let direct_clicks = (total_clicks - qr_scans).max(0);
+
+    let clicks_data = get_clicks_trend(&conn, "url", &id, 30)
+        .or_else(|_| get_clicks_trend_raw(&conn, "url", &id, 30))
+        .unwrap_or_default();
+    let mut trend_map = std::collections::BTreeMap::new();
+    for i in (0..30).rev() {
+        let date_str = (Utc::now() - chrono::Duration::days(i))
+            .format("%Y-%m-%d")
+            .to_string();
+        trend_map.insert(date_str, 0i64);
+    }
+    for (d, c) in clicks_data {
+        trend_map.insert(d, c);
+    }
+    let formatted_trend: Vec<(String, i64)> = trend_map.into_iter().collect();
+    let traffic_chart = generate_line_chart(&formatted_trend);
+
+    let monthly_data = get_monthly_clicks_trend(&conn, "url", &id, 12).unwrap_or_default();
+    let monthly_chart = generate_line_chart(&monthly_data);
+
+    let countries_data = get_metric_rankings(&conn, "url", &id, "country", 5)
+        .or_else(|_| get_metric_rankings_raw(&conn, "url", &id, "country", 5))
+        .unwrap_or_default();
+    let countries_chart = generate_bar_chart(&countries_data);
+
+    let referrers_data = get_metric_rankings(&conn, "url", &id, "referrer", 5)
+        .or_else(|_| get_metric_rankings_raw(&conn, "url", &id, "referrer", 5))
+        .unwrap_or_default();
+    let referrers_chart = generate_bar_chart(&referrers_data);
+
+    let browsers_data = get_metric_rankings(&conn, "url", &id, "browser", 5)
+        .or_else(|_| get_metric_rankings_raw(&conn, "url", &id, "browser", 5))
+        .unwrap_or_default();
+    let browsers_chart = generate_bar_chart(&browsers_data);
+
+    let calculated_total_pages = (total_clicks as usize).div_ceil(ANALYTICS_PAGE_SIZE);
+    let total_pages = std::cmp::max(1, calculated_total_pages);
+    let requested_page = query.analytics_page.unwrap_or(1);
+    let current_page = if requested_page == 0 { 1 } else { requested_page }.clamp(1, total_pages);
+    let offset = (current_page - 1) * ANALYTICS_PAGE_SIZE;
+
+    let visits_raw = get_target_visits_paginated(
+        &conn,
+        "url",
+        &id,
+        ANALYTICS_PAGE_SIZE as i64,
+        offset as i64,
+        clean_date_from.as_deref(),
+        clean_date_to.as_deref(),
+    ).unwrap_or_default();
+
+    let visits: Vec<crate::templates::VisitorLogEntry> = visits_raw
+        .into_iter()
+        .enumerate()
+        .map(|(idx, r)| {
+            let (browser, _, _) = parse_ua(&r.user_agent);
+            let referrer = clean_referrer(&r.referer);
+            let sr = offset + idx + 1;
+            crate::templates::VisitorLogEntry {
+                sr,
+                timestamp: r.timestamp,
+                ip_address: r.ip_address,
+                country: if r.country.is_empty() { "Unknown".to_string() } else { r.country },
+                referrer,
+                browser,
+                user_agent: r.user_agent,
+                utm_source: "-".to_string(),
+                utm_campaign: "-".to_string(),
+            }
+        })
+        .collect();
+
+    let start_page = current_page.saturating_sub(3).max(1);
+    let end_page = std::cmp::min(total_pages, current_page + 3);
+    let visible_pages: Vec<usize> = (start_page..=end_page).collect();
+
+    let page_start = if total_clicks == 0 { 0 } else { offset + 1 };
+    let page_end = if total_clicks == 0 { 0 } else { std::cmp::min(total_clicks as usize, offset + ANALYTICS_PAGE_SIZE) };
+
+    let template = crate::templates::UrlAnalyticsTemplate {
+        admin_username: user.username,
+        url,
+        total_clicks,
+        unique_visitors,
+        qr_scans,
+        direct_clicks,
+        traffic_chart,
+        monthly_chart,
+        countries_chart,
+        referrers_chart,
+        browsers_chart,
+        visits,
+        current_page,
+        total_pages,
+        visible_pages,
+        total_records: total_clicks,
+        page_start,
+        page_end,
+        date_from: clean_date_from,
+        date_to: clean_date_to,
+    };
+
+    template.into_response()
+}
+
+// GET /admin/analytics/page/:id
+pub async fn page_analytics_get(
+    State(state): State<AppState>,
+    jar: CookieJar,
+    Path(id): Path<String>,
+    Query(query): Query<AnalyticsQuery>,
+) -> Response {
+    let (user, _) = match require_auth(&state, &jar).await {
+        Ok(u) => u,
+        Err(redir) => return redir.into_response(),
+    };
+
+    let page = {
+        let conn = state.content_db.lock().unwrap();
+        match get_landing_page_by_id(&conn, &id) {
+            Ok(Some(p)) => p,
+            Ok(None) => return (StatusCode::NOT_FOUND, "Landing page not found").into_response(),
+            Err(_) => return (StatusCode::INTERNAL_SERVER_ERROR, "Database error").into_response(),
+        }
+    };
+
+    let conn = state.analytics_db.lock().unwrap();
+
+    let schema_cols = get_visits_schema_columns(&conn).unwrap_or_default();
+    let has_utm_source = schema_cols.contains("utm_source");
+    let has_utm_campaign = schema_cols.contains("utm_campaign");
+    if has_utm_source || has_utm_campaign {
+        return (StatusCode::INTERNAL_SERVER_ERROR, "UTM mapping verification failed").into_response();
+    }
+
+    let (clean_date_from, clean_date_to) = match validate_date_filters(
+        query.date_from.as_deref(),
+        query.date_to.as_deref(),
+    ) {
+        Ok(res) => res,
+        Err(status) => return status.into_response(),
+    };
+
+    let total_views = get_target_visit_total_filtered(
+        &conn,
+        "page",
+        &id,
+        clean_date_from.as_deref(),
+        clean_date_to.as_deref(),
+    ).unwrap_or(0);
+
+    let unique_visitors = get_target_unique_visitors(&conn, "page", &id).unwrap_or(0);
+
+    let clicks_data = get_clicks_trend(&conn, "page", &id, 30)
+        .or_else(|_| get_clicks_trend_raw(&conn, "page", &id, 30))
+        .unwrap_or_default();
+    let mut trend_map = std::collections::BTreeMap::new();
+    for i in (0..30).rev() {
+        let date_str = (Utc::now() - chrono::Duration::days(i))
+            .format("%Y-%m-%d")
+            .to_string();
+        trend_map.insert(date_str, 0i64);
+    }
+    for (d, c) in clicks_data {
+        trend_map.insert(d, c);
+    }
+    let formatted_trend: Vec<(String, i64)> = trend_map.into_iter().collect();
+    let traffic_chart = generate_line_chart(&formatted_trend);
+
+    let monthly_data = get_monthly_clicks_trend(&conn, "page", &id, 12).unwrap_or_default();
+    let monthly_chart = generate_line_chart(&monthly_data);
+
+    let countries_data = get_metric_rankings(&conn, "page", &id, "country", 5)
+        .or_else(|_| get_metric_rankings_raw(&conn, "page", &id, "country", 5))
+        .unwrap_or_default();
+    let countries_chart = generate_bar_chart(&countries_data);
+
+    let referrers_data = get_metric_rankings(&conn, "page", &id, "referrer", 5)
+        .or_else(|_| get_metric_rankings_raw(&conn, "page", &id, "referrer", 5))
+        .unwrap_or_default();
+    let referrers_chart = generate_bar_chart(&referrers_data);
+
+    let calculated_total_pages = (total_views as usize).div_ceil(ANALYTICS_PAGE_SIZE);
+    let total_pages = std::cmp::max(1, calculated_total_pages);
+    let requested_page = query.analytics_page.unwrap_or(1);
+    let current_page = if requested_page == 0 { 1 } else { requested_page }.clamp(1, total_pages);
+    let offset = (current_page - 1) * ANALYTICS_PAGE_SIZE;
+
+    let visits_raw = get_target_visits_paginated(
+        &conn,
+        "page",
+        &id,
+        ANALYTICS_PAGE_SIZE as i64,
+        offset as i64,
+        clean_date_from.as_deref(),
+        clean_date_to.as_deref(),
+    ).unwrap_or_default();
+
+    let visits: Vec<crate::templates::VisitorLogEntry> = visits_raw
+        .into_iter()
+        .enumerate()
+        .map(|(idx, r)| {
+            let (browser, _, _) = parse_ua(&r.user_agent);
+            let referrer = clean_referrer(&r.referer);
+            let sr = offset + idx + 1;
+            crate::templates::VisitorLogEntry {
+                sr,
+                timestamp: r.timestamp,
+                ip_address: r.ip_address,
+                country: if r.country.is_empty() { "Unknown".to_string() } else { r.country },
+                referrer,
+                browser,
+                user_agent: r.user_agent,
+                utm_source: "-".to_string(),
+                utm_campaign: "-".to_string(),
+            }
+        })
+        .collect();
+
+    let start_page = current_page.saturating_sub(3).max(1);
+    let end_page = std::cmp::min(total_pages, current_page + 3);
+    let visible_pages: Vec<usize> = (start_page..=end_page).collect();
+
+    let page_start = if total_views == 0 { 0 } else { offset + 1 };
+    let page_end = if total_views == 0 { 0 } else { std::cmp::min(total_views as usize, offset + ANALYTICS_PAGE_SIZE) };
+
+    let template = crate::templates::PageAnalyticsTemplate {
+        admin_username: user.username,
+        page,
+        total_views,
+        unique_visitors,
+        traffic_chart,
+        monthly_chart,
+        countries_chart,
+        referrers_chart,
+        visits,
+        current_page,
+        total_pages,
+        visible_pages,
+        total_records: total_views,
+        page_start,
+        page_end,
+        date_from: clean_date_from,
+        date_to: clean_date_to,
+    };
+
+    template.into_response()
+}
+
+pub async fn url_analytics_csv_export(
+    State(state): State<AppState>,
+    jar: CookieJar,
+    Path(id): Path<String>,
+    Query(query): Query<AnalyticsQuery>,
+) -> Response {
+    if require_auth(&state, &jar).await.is_err() {
+        return StatusCode::UNAUTHORIZED.into_response();
+    }
+    perform_csv_export(state, "url", id, query.date_from, query.date_to).await
+}
+
+pub async fn url_analytics_json_export(
+    State(state): State<AppState>,
+    jar: CookieJar,
+    Path(id): Path<String>,
+    Query(query): Query<AnalyticsQuery>,
+) -> Response {
+    if require_auth(&state, &jar).await.is_err() {
+        return StatusCode::UNAUTHORIZED.into_response();
+    }
+    perform_json_export(state, "url", id, query.date_from, query.date_to).await
+}
+
+pub async fn page_analytics_csv_export(
+    State(state): State<AppState>,
+    jar: CookieJar,
+    Path(id): Path<String>,
+    Query(query): Query<AnalyticsQuery>,
+) -> Response {
+    if require_auth(&state, &jar).await.is_err() {
+        return StatusCode::UNAUTHORIZED.into_response();
+    }
+    perform_csv_export(state, "page", id, query.date_from, query.date_to).await
+}
+
+pub async fn page_analytics_json_export(
+    State(state): State<AppState>,
+    jar: CookieJar,
+    Path(id): Path<String>,
+    Query(query): Query<AnalyticsQuery>,
+) -> Response {
+    if require_auth(&state, &jar).await.is_err() {
+        return StatusCode::UNAUTHORIZED.into_response();
+    }
+    perform_json_export(state, "page", id, query.date_from, query.date_to).await
+}
+

src/web/routes.rs

@@ -37,6 +37,12 @@ pub fn create_router(state: AppState) -> Router {
         .route("/admin/pages", get(admin::pages_get))
         .route("/admin/pages/create", post(admin::pages_create))
         .route("/admin/pages/delete/:id", post(admin::pages_delete))
+        .route("/admin/analytics/url/:id", get(admin::url_analytics_get))
+        .route("/admin/analytics/url/:id/export/csv", get(admin::url_analytics_csv_export))
+        .route("/admin/analytics/url/:id/export/json", get(admin::url_analytics_json_export))
+        .route("/admin/analytics/page/:id", get(admin::page_analytics_get))
+        .route("/admin/analytics/page/:id/export/csv", get(admin::page_analytics_csv_export))
+        .route("/admin/analytics/page/:id/export/json", get(admin::page_analytics_json_export))
         .route("/admin/settings", get(admin::settings_get))
         .route(
             "/admin/settings/password",