start with splitting server

1 files changed, 6 insertions, 200 deletions

diff --git a/server/src/ui/sort.rs b/server/src/ui/sort.rs
index a241030..441bac6 100644
--- a/server/src/ui/sort.rs
+++ b/server/src/ui/sort.rs
@@ -3,149 +3,18 @@
     which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
     Copyright (C) 2025 metamuffin <metamuffin.org>
 */
-use crate::ui::layout::trs;
-use jellybase::locale::Language;
-use jellycommon::{helpers::SortAnyway, user::NodeUserData, Node, NodeKind, Rating};
-use markup::RenderAttributeValue;
+use jellycommon::{
+    api::{FilterProperty, NodeFilterSort, SortOrder, SortProperty},
+    helpers::SortAnyway,
+    user::NodeUserData,
+    Node, NodeKind, Rating,
+};
 use rocket::{
     http::uri::fmt::{Query, UriDisplay},
     FromForm, FromFormField, UriDisplayQuery,
 };
 use std::sync::Arc;
 
-#[derive(FromForm, UriDisplayQuery, Default, Clone)]
-pub struct NodeFilterSort {
-    pub sort_by: Option<SortProperty>,
-    pub filter_kind: Option<Vec<FilterProperty>>,
-    pub sort_order: Option<SortOrder>,
-}
-
-macro_rules! form_enum {
-    (enum $i:ident { $($vi:ident = $vk:literal),*, }) => {
-        #[derive(Debug, FromFormField, UriDisplayQuery, Clone, Copy, PartialEq, Eq)]
-        pub enum $i { $(#[field(value = $vk)] $vi),* }
-        impl $i { #[allow(unused)] const ALL: &'static [$i] = &[$($i::$vi),*]; }
-    };
-}
-
-form_enum!(
-    enum FilterProperty {
-        FederationLocal = "fed_local",
-        FederationRemote = "fed_remote",
-        Watched = "watched",
-        Unwatched = "unwatched",
-        WatchProgress = "watch_progress",
-        KindMovie = "kind_movie",
-        KindVideo = "kind_video",
-        KindShortFormVideo = "kind_short_form_video",
-        KindMusic = "kind_music",
-        KindCollection = "kind_collection",
-        KindChannel = "kind_channel",
-        KindShow = "kind_show",
-        KindSeries = "kind_series",
-        KindSeason = "kind_season",
-        KindEpisode = "kind_episode",
-    }
-);
-
-form_enum!(
-    enum SortProperty {
-        ReleaseDate = "release_date",
-        Title = "title",
-        Index = "index",
-        Duration = "duration",
-        RatingRottenTomatoes = "rating_rt",
-        RatingMetacritic = "rating_mc",
-        RatingImdb = "rating_imdb",
-        RatingTmdb = "rating_tmdb",
-        RatingYoutubeViews = "rating_yt_views",
-        RatingYoutubeLikes = "rating_yt_likes",
-        RatingYoutubeFollowers = "rating_yt_followers",
-        RatingUser = "rating_user",
-        RatingLikesDivViews = "rating_loved",
-    }
-);
-
-impl SortProperty {
-    const CATS: &'static [(&'static str, &'static [(SortProperty, &'static str)])] = {
-        use SortProperty::*;
-        &[
-            (
-                "filter_sort.sort.general",
-                &[(Title, "node.title"), (ReleaseDate, "node.release_date")],
-            ),
-            ("filter_sort.sort.media", &[(Duration, "media.runtime")]),
-            (
-                "filter_sort.sort.rating",
-                &[
-                    (RatingImdb, "rating.imdb"),
-                    (RatingTmdb, "rating.tmdb"),
-                    (RatingMetacritic, "rating.metacritic"),
-                    (RatingRottenTomatoes, "rating.rotten_tomatoes"),
-                    (RatingYoutubeFollowers, "rating.youtube_followers"),
-                    (RatingYoutubeLikes, "rating.youtube_likes"),
-                    (RatingYoutubeViews, "rating.youtube_views"),
-                    (RatingUser, "filter_sort.sort.rating.user"),
-                    (
-                        RatingLikesDivViews,
-                        "filter_sort.sort.rating.likes_div_views",
-                    ),
-                ],
-            ),
-        ]
-    };
-}
-impl FilterProperty {
-    const CATS: &'static [(&'static str, &'static [(FilterProperty, &'static str)])] = {
-        use FilterProperty::*;
-        &[
-            (
-                "filter_sort.filter.kind",
-                &[
-                    (KindMovie, "kind.movie"),
-                    (KindVideo, "kind.video"),
-                    (KindShortFormVideo, "kind.short_form_video"),
-                    (KindMusic, "kind.music"),
-                    (KindCollection, "kind.collection"),
-                    (KindChannel, "kind.channel"),
-                    (KindShow, "kind.show"),
-                    (KindSeries, "kind.series"),
-                    (KindSeason, "kind.season"),
-                    (KindEpisode, "kind.episode"),
-                ],
-            ),
-            (
-                "filter_sort.filter.federation",
-                &[
-                    (FederationLocal, "federation.local"),
-                    (FederationRemote, "federation.remote"),
-                ],
-            ),
-            (
-                "filter_sort.filter.watched",
-                &[
-                    (Watched, "watched.watched"),
-                    (Unwatched, "watched.none"),
-                    (WatchProgress, "watched.progress"),
-                ],
-            ),
-        ]
-    };
-}
-
-impl NodeFilterSort {
-    pub fn is_open(&self) -> bool {
-        self.filter_kind.is_some() || self.sort_by.is_some()
-    }
-}
-
-#[rustfmt::skip]
-#[derive(FromFormField, UriDisplayQuery, Clone, Copy, PartialEq, Eq)]
-pub enum SortOrder {
-    #[field(value = "ascending")] Ascending,
-    #[field(value = "descending")] Descending,
-}
-
 pub fn filter_and_sort_nodes(
     f: &NodeFilterSort,
     default_sort: (SortProperty, SortOrder),
@@ -232,66 +101,3 @@ pub fn filter_and_sort_nodes(
         SortOrder::Descending => nodes.reverse(),
     }
 }
-
-markup::define! {
-    NodeFilterSortForm<'a>(f: &'a NodeFilterSort, lang: &'a Language) {
-        details.filtersort[open=f.is_open()] {
-            summary { "Filter and Sort" }
-            form[method="GET", action=""] {
-                fieldset.filter {
-                    legend { "Filter" }
-                    .categories {
-                        @for (cname, cat) in FilterProperty::CATS {
-                            .category {
-                                h3 { @trs(lang, cname) }
-                                @for (value, label) in *cat {
-                                    label { input[type="checkbox", name="filter_kind", value=value, checked=f.filter_kind.as_ref().map(|k|k.contains(value)).unwrap_or(true)]; @trs(lang, label) } br;
-                                }
-                            }
-                        }
-                    }
-                }
-                fieldset.sortby {
-                    legend { "Sort" }
-                    .categories {
-                        @for (cname, cat) in SortProperty::CATS {
-                            .category {
-                                h3 { @trs(lang, cname) }
-                                @for (value, label) in *cat {
-                                    label { input[type="radio", name="sort_by", value=value, checked=Some(value)==f.sort_by.as_ref()]; @trs(lang, label) } br;
-                                }
-                            }
-                        }
-                    }
-                }
-                fieldset.sortorder {
-                    legend { "Sort Order" }
-                    @use SortOrder::*;
-                    @for (value, label) in [(Ascending, "filter_sort.order.asc"), (Descending, "filter_sort.order.desc")] {
-                        label { input[type="radio", name="sort_order", value=value, checked=Some(value)==f.sort_order]; @trs(lang, label) } br;
-                    }
-                }
-                input[type="submit", value="Apply"]; a[href="?"] { "Clear" }
-            }
-        }
-    }
-}
-
-impl markup::Render for SortProperty {
-    fn render(&self, writer: &mut impl std::fmt::Write) -> std::fmt::Result {
-        writer.write_fmt(format_args!("{}", self as &dyn UriDisplay<Query>))
-    }
-}
-impl markup::Render for SortOrder {
-    fn render(&self, writer: &mut impl std::fmt::Write) -> std::fmt::Result {
-        writer.write_fmt(format_args!("{}", self as &dyn UriDisplay<Query>))
-    }
-}
-impl markup::Render for FilterProperty {
-    fn render(&self, writer: &mut impl std::fmt::Write) -> std::fmt::Result {
-        writer.write_fmt(format_args!("{}", self as &dyn UriDisplay<Query>))
-    }
-}
-impl RenderAttributeValue for SortOrder {}
-impl RenderAttributeValue for FilterProperty {}
-impl RenderAttributeValue for SortProperty {}