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

use std::{num::NonZeroU32, sync::Arc};

use async_trait::async_trait;
use fancy_regex::Regex;
use serde::Serialize;
use tokio::sync::MutexGuard;

use crate::internal::database::provider::Connection;

use super::database::provider::Database;

pub type DivisionEligibilityProvider = Arc<dyn DivisionEligible + Send + Sync>;

#[async_trait]
pub trait DivisionEligible {
    async fn is_user_eligible(
        &self,
        user_id: i64,
        db: &Arc<dyn Database + Send + Sync>,
    ) -> std::result::Result<bool, String>;
}

pub struct EmailDivisionEligibilityProvider {
    pub regex: Regex,
    pub requirement: String,
}

impl EmailDivisionEligibilityProvider {
    pub fn new(regex: &str, requirement: Option<String>) -> Self {
        let r = Regex::new(regex).unwrap();
        Self {
            regex: r,
            requirement: requirement.unwrap_or(format!("Email must match regex {regex}")),
        }
    }
}

#[async_trait]
impl DivisionEligible for EmailDivisionEligibilityProvider {
    async fn is_user_eligible(
        &self,
        user_id: i64,
        db: &Arc<dyn Database + Send + Sync>,
    ) -> std::result::Result<bool, String> {
        let emails = db.get_emails_for_user_id(user_id).await.unwrap();
        let eligible = emails
            .iter()
            .filter(|email| email.verified)
            .any(|email| self.regex.is_match(&email.address).unwrap());

        if eligible {
            Ok(true)
        } else {
            Err(self.requirement.clone())
        }
    }
}

pub struct OpenDivisionEligibilityProvider;

#[async_trait]
impl DivisionEligible for OpenDivisionEligibilityProvider {
    async fn is_user_eligible(
        &self,
        _user_id: i64,
        _db: &Arc<dyn Database + Send + Sync>,
    ) -> std::result::Result<bool, String> {
        Ok(true)
    }
}

#[derive(Serialize, Clone)]
pub struct Division {
    pub id: i64,
    pub name: String,
    pub description: String,
    pub max_players: MaxDivisionPlayers,

    #[serde(skip)]
    pub division_eligibility: DivisionEligibilityProvider,
}

#[derive(Debug, Serialize, Clone)]
pub enum MaxDivisionPlayers {
    Unlimited,
    Limited(NonZeroU32),
}