refactor

src/routes/ui/repo.rs

@@ -0,0 +1,163 @@
+use based::request::{RequestContext, StringResponse};
+use based::ui::prelude::*;
+use maud::{PreEscaped, Render, html};
+use rocket::{State, get};
+
+use pacco::pkg::{Repository, arch::Architecture};
+
+use crate::config::Config;
+use crate::routes::ui::arch_card;
+
+use super::render;
+
+#[get("/<repo>?<arch>")]
+pub async fn repo_ui(
+    repo: &str,
+    ctx: RequestContext,
+    arch: Option<&str>,
+    config: &State<Config>,
+) -> StringResponse {
+    let arch = arch.map(|x| Architecture::parse(x).unwrap_or(Architecture::any));
+
+    let repo = Repository::new(repo).unwrap();
+    let architectures: Vec<_> = repo.arch().into_iter().map(|x| x.to_string()).collect();
+    let packages = if let Some(arch) = arch.clone() {
+        repo.list_pkg_arch(arch)
+    } else {
+        repo.list_pkg()
+    };
+
+    // Repository name and architectures
+    let repo_info = Margin(
+        Flex(
+            Div()
+                .vanish()
+                .push(Text(&repo.name)._3xl().bold().color(&Gray::_100))
+                .push_if(config.is_mirrored_repo(&repo.name), || {
+                    Background(
+                        Blue::_500,
+                        Rounded(Margin(
+                            Padding(Text("Mirrored").sm().medium().white())
+                                .x(ScreenValue::_3)
+                                .y(ScreenValue::_1),
+                        ))
+                        .size(Size::Full),
+                    )
+                })
+                .push(
+                    Screen::medium(Margin(Nothing()).top(ScreenValue::_0)).on(Margin(
+                        Flex(Div().vanish().push_for_each(&architectures, |a: &String| {
+                            html! {
+                                @if let Some(arch) = arch.as_ref() {
+                                    @if arch.to_string() == *a {
+                                        (arch_card(&a, &repo.name, true))
+                                    } @else {
+                                        (arch_card(&a, &repo.name, false))
+                                    }
+                                } @else {
+                                    (arch_card(&a, &repo.name, false))
+                            }
+                            }
+                        }))
+                        .group()
+                        .gap(ScreenValue::_2),
+                    )
+                    .top(ScreenValue::_2)),
+                )
+                .push(
+                    Text(&format!("{} packages", packages.len()))
+                        .sm()
+                        .color(&Gray::_100),
+                ),
+        )
+        .gap(ScreenValue::_3)
+        .wrap(Wrap::Wrap)
+        .full_center()
+        .group(),
+    )
+    .bottom(ScreenValue::_6);
+
+    let package_list = SpaceBetween(Div().vanish().push_for_each(&packages, |pkg| {
+        Animated(
+            Flex(
+                Padding(
+                    Hover(Background(Gray::_600, Nothing())).on(Background(
+                        Gray::_700,
+                        Rounded(Shadow::medium(
+                            Link(
+                                &format!("/{}/{pkg}", repo.name),
+                                Div()
+                                    .vanish()
+                                    .push(FirstLetterCircle(pkg))
+                                    .push(Context(Width(
+                                        ScreenValue::fit,
+                                        Text(&pkg).medium().color(&Gray::_100),
+                                    )))
+                                    .push_if(
+                                        repo.get_pkg_by_name(&pkg)
+                                            .map(|x| x.sig_content())
+                                            .is_some(),
+                                        || SignedInfo(),
+                                    ),
+                            )
+                            .use_htmx(),
+                        ))
+                        .size(Size::Large),
+                    )),
+                )
+                .all(ScreenValue::_4),
+            )
+            .items_center()
+            .gap(ScreenValue::_4),
+        )
+    }))
+    .y(ScreenValue::_4);
+
+    let content = Div().vanish().push(repo_info).push(package_list).render();
+
+    render(content, &repo.name, ctx).await
+}
+
+#[allow(non_snake_case)]
+pub fn FirstLetterCircle(name: &str) -> PreEscaped<String> {
+    Sized(
+        ScreenValue::_10,
+        ScreenValue::_10,
+        Rounded(Background(
+            Blue::_500,
+            Flex(
+                Text(
+                    &name
+                        .chars()
+                        .next()
+                        .unwrap_or_default()
+                        .to_uppercase()
+                        .to_string(),
+                )
+                .white()
+                .semibold(),
+            )
+            .full_center()
+            .group(),
+        ))
+        .size(Size::Full),
+    )
+    .render()
+}
+
+#[allow(non_snake_case)]
+pub fn SignedInfo() -> PreEscaped<String> {
+    Padding(
+        Flex(
+            Div()
+                .vanish()
+                .push(Span("✓")._2xl().bold().color(&Slate::_300))
+                .push(Span("Signed").sm().medium().color(&Slate::_300)),
+        )
+        .items_center()
+        .gap(ScreenValue::_2)
+        .group(),
+    )
+    .right(ScreenValue::_4)
+    .render()
+}