1 files changed, 0 insertions, 133 deletions
diff --git a/server/src/routes/ui/stats.rs b/server/src/routes/ui/stats.rs
deleted file mode 100644
index 4e4eef1..0000000
--- a/server/src/routes/ui/stats.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
-    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
-    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
-    Copyright (C) 2025 metamuffin <metamuffin.org>
-*/
-use super::{
-    account::session::Session,
-    error::MyError,
-    layout::{DynLayoutPage, LayoutPage},
-};
-use crate::{
-    database::Database,
-    routes::{
-        api::AcceptJson,
-        locale::AcceptLanguage,
-        ui::{
-            layout::trs,
-            node::{
-                format_duration, format_duration_long, format_kind, format_size,
-                rocket_uri_macro_r_library_node,
-            },
-        },
-    },
-    uri,
-};
-use jellybase::locale::tr;
-use jellycommon::{Node, NodeID, NodeKind, Visibility};
-use markup::raw;
-use rocket::{get, serde::json::Json, Either, State};
-use serde::Serialize;
-use serde_json::{json, Value};
-use std::collections::BTreeMap;
-
-#[get("/stats")]
-pub fn r_stats(
-    sess: Session,
-    db: &State<Database>,
-    aj: AcceptJson,
-    lang: AcceptLanguage,
-) -> Result<Either<DynLayoutPage<'_>, Json<Value>>, MyError> {
-    let AcceptLanguage(lang) = lang;
-    let mut items = db.list_nodes_with_udata(sess.user.name.as_str())?;
-    items.retain(|(n, _)| n.visibility >= Visibility::Reduced);
-
-    #[derive(Default, Serialize)]
-    struct Bin {
-        runtime: f64,
-        size: u64,
-        count: usize,
-        max_runtime: (f64, String),
-        max_size: (u64, String),
-    }
-    impl Bin {
-        fn update(&mut self, node: &Node) {
-            self.count += 1;
-            self.size += node.storage_size;
-            if node.storage_size > self.max_size.0 {
-                self.max_size = (node.storage_size, node.slug.clone())
-            }
-            if let Some(m) = &node.media {
-                self.runtime += m.duration;
-                if m.duration > self.max_runtime.0 {
-                    self.max_runtime = (m.duration, node.slug.clone())
-                }
-            }
-        }
-        fn average_runtime(&self) -> f64 {
-            self.runtime / self.count as f64
-        }
-        fn average_size(&self) -> f64 {
-            self.size as f64 / self.count as f64
-        }
-    }
-
-    let mut all = Bin::default();
-    let mut kinds = BTreeMap::<NodeKind, Bin>::new();
-    for (i, _) in items {
-        all.update(&i);
-        kinds.entry(i.kind).or_default().update(&i);
-    }
-
-    Ok(if *aj {
-        Either::Right(Json(json!({
-            "all": all,
-            "kinds": kinds,
-        })))
-    } else {
-        Either::Left(LayoutPage {
-            title: tr(lang, "stats.title").to_string(),
-            content: markup::new! {
-                .page.stats {
-                    h1 { @trs(&lang, "stats.title") }
-                    p { @raw(tr(lang, "stats.count")
-                        .replace("{count}", &format!("<b>{}</b>", all.count))
-                    )}
-                    p { @raw(tr(lang, "stats.runtime")
-                        .replace("{dur}", &format!("<b>{}</b>", format_duration_long(all.runtime, lang)))
-                        .replace("{size}", &format!("<b>{}</b>", format_size(all.size)))
-                    )}
-                    p { @raw(tr(lang, "stats.average")
-                        .replace("{dur}", &format!("<b>{}</b>",  format_duration(all.average_runtime())))
-                        .replace("{size}", &format!("<b>{}</b>", format_size(all.average_size() as u64)))
-                    )}
-
-                    h2 { @trs(&lang, "stats.by_kind.title") }
-                    table.striped {
-                        tr {
-                            th { @trs(&lang, "stats.by_kind.kind") }
-                            th { @trs(&lang, "stats.by_kind.count") }
-                            th { @trs(&lang, "stats.by_kind.total_size") }
-                            th { @trs(&lang, "stats.by_kind.total_runtime") }
-                            th { @trs(&lang, "stats.by_kind.average_size") }
-                            th { @trs(&lang, "stats.by_kind.average_runtime") }
-                            th { @trs(&lang, "stats.by_kind.max_size") }
-                            th { @trs(&lang, "stats.by_kind.max_runtime") }
-                        }
-                        @for (k,b) in &kinds { tr {
-                            td { @format_kind(*k, lang) }
-                            td { @b.count }
-                            td { @format_size(b.size) }
-                            td { @format_duration(b.runtime) }
-                            td { @format_size(b.average_size() as u64) }
-                            td { @format_duration(b.average_runtime()) }
-                            td { @if b.max_size.0 > 0 { a[href=uri!(r_library_node(&b.max_size.1))]{ @format_size(b.max_size.0) }}}
-                            td { @if b.max_runtime.0 > 0. { a[href=uri!(r_library_node(&b.max_runtime.1))]{ @format_duration(b.max_runtime.0) }}}
-                        }}
-                    }
-                }
-            },
-            ..Default::default()
-        })
-    })
-}