rhombus 0.2.21

Next generation extendable CTF framework with batteries included
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use axum::{
    extract::{Path, Query, State},
    http::Uri,
    response::{Html, IntoResponse, Redirect},
    Extension, Json,
};
use minijinja::context;
use serde::Deserialize;
use serde_json::json;

use crate::internal::{auth::MaybeUser, router::RouterState, routes::meta::PageMeta};

pub async fn route_scoreboard(
    State(state): State<RouterState>,
    user: Extension<MaybeUser>,
    page: Extension<PageMeta>,
    params: Query<PageParams>,
    uri: Uri,
) -> impl IntoResponse {
    let challenge_data = state.db.get_challenges().await.unwrap();
    let default_division = challenge_data.divisions.keys().next().unwrap();
    if challenge_data.divisions.len() == 1 {
        return route_scoreboard_division(
            State(state),
            user,
            page,
            Path(default_division.to_string()),
            params,
            uri,
        )
        .await
        .into_response();
    }

    Redirect::temporary(
        format!(
            "/scoreboard/{}{}",
            default_division,
            if uri.path().ends_with(".json") {
                ".json"
            } else {
                ""
            }
        )
        .as_str(),
    )
    .into_response()
}

#[derive(Deserialize)]
pub struct PageParams {
    page: Option<u64>,
}

pub async fn route_scoreboard_division(
    state: State<RouterState>,
    Extension(user): Extension<MaybeUser>,
    Extension(page): Extension<PageMeta>,
    Path(division_id): Path<String>,
    params: Query<PageParams>,
    uri: Uri,
) -> impl IntoResponse {
    let page_num = params.page.unwrap_or(1).saturating_sub(1);

    let Ok(division_id) = division_id
        .strip_suffix(".json")
        .unwrap_or(&division_id)
        .parse()
    else {
        return Err::<(), &str>("Failed to parse division ID as integer").into_response();
    };

    let scoreboard = state.db.get_scoreboard(division_id);
    let challenge_data = state.db.get_challenges();
    let leaderboard = state.db.get_leaderboard(division_id, Some(page_num));
    let (scoreboard, challenge_data, leaderboard) =
        futures::future::try_join3(scoreboard, challenge_data, leaderboard)
            .await
            .unwrap();

    if uri.path().ends_with(".json") {
        return Json(scoreboard.teams).into_response();
    }

    Html(
        state
            .jinja
            .get_template("scoreboard.html")
            .unwrap()
            .render(context! {
                global => state.global_page_meta,
                page,
                user,
                uri => "/scoreboard",
                title => format!("Scoreboard | {}", state.global_page_meta.title),
                scoreboard => scoreboard.teams,
                divisions => challenge_data.divisions,
                leaderboard,
                selected_division_id => division_id,
                page_num,
            })
            .unwrap(),
    )
    .into_response()
}

/// Implements the feed as described by https://ctftime.org/json-scoreboard-feed
pub async fn route_scoreboard_division_ctftime(
    state: State<RouterState>,
    Path(division_id): Path<i64>,
) -> impl IntoResponse {
    let challenge_data = state.db.get_challenges().await.unwrap();
    let leaderboard = state.db.get_leaderboard(division_id, None).await.unwrap();

    let tasks = challenge_data
        .challenges
        .iter()
        .map(|challenge| &challenge.name)
        .collect::<Vec<_>>();

    let standings = leaderboard
        .entries
        .iter()
        .map(|team| {
            json!({
                "pos": team.rank,
                "team": team.team_name,
                "score": team.score,
            })
        })
        .collect::<Vec<_>>();

    Json(json!({ "tasks": tasks, "standings": standings }))
}