rsmycqu 0.1.0

A Rust library for interacting with Chonqing University services, including SSO authentication, campus card management, and more.
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

use std::{collections::HashMap, ops::Deref, sync::Mutex};

use rstest::*;

#[cfg(feature = "card")]
use crate::card::access_card;
use crate::{
    mycqu::access_mycqu,
    session::Session,
    sso::{LoginResult, login},
};

#[derive(Debug, Eq, PartialEq)]
pub(crate) struct LoginData {
    pub auth: String,
    pub password: String,
    pub student_id: String,
}

#[fixture]
#[once]
pub(crate) fn login_data() -> LoginData {
    LoginData {
        auth: std::env::var("AUTH").unwrap(),
        password: std::env::var("PASSWORD").unwrap(),
        student_id: std::env::var("STUDENT_ID").unwrap(),
    }
}

#[derive(Hash, Eq, PartialEq)]
pub(crate) enum SessionType {
    Login,
    AccessMycqu,
    #[cfg(feature = "card")]
    AccessCard,
}

pub(crate) struct ShareSessionMap(Mutex<HashMap<SessionType, Session>>);

impl Deref for ShareSessionMap {
    type Target = Mutex<HashMap<SessionType, Session>>;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl ShareSessionMap {
    fn get_session(&self, session_type: &SessionType) -> Option<Session> {
        self.lock()
            .ok()
            .and_then(|session_pool| session_pool.get(session_type).cloned())
    }
}

#[fixture]
#[once]
fn session_map() -> ShareSessionMap {
    ShareSessionMap(Mutex::new(HashMap::new()))
}

#[fixture]
pub(crate) async fn login_session(
    session_map: &ShareSessionMap,
    login_data: &LoginData,
) -> Session {
    match session_map.get_session(&SessionType::Login) {
        None => {
            let mut session = Session::new();
            let res = login(&mut session, &login_data.auth, &login_data.password, false).await;

            assert_eq!(res.unwrap(), LoginResult::Success);

            {
                let mut session_pool = session_map.lock().unwrap();
                (*session_pool).insert(SessionType::Login, session.clone());
            }

            session
        }
        Some(session) => session.clone(),
    }
}

#[fixture]
pub(crate) async fn access_mycqu_session(
    session_map: &ShareSessionMap,
    #[future] login_session: Session,
) -> Session {
    match session_map.get_session(&SessionType::AccessMycqu) {
        None => {
            let mut session = login_session.await;
            access_mycqu(&mut session).await.unwrap();

            {
                let mut session_pool = session_map.lock().unwrap();
                (*session_pool).insert(SessionType::AccessMycqu, session.clone());
            }

            session
        }
        Some(session) => session.clone(),
    }
}

#[cfg(feature = "card")]
#[fixture]
pub(crate) async fn access_card_session(
    session_map: &ShareSessionMap,
    #[future] login_session: Session,
) -> Session {
    match session_map.get_session(&SessionType::AccessCard) {
        None => {
            let mut session = login_session.await;
            access_card(&mut session).await.unwrap();

            {
                let mut session_pool = session_map.lock().unwrap();
                (*session_pool).insert(SessionType::AccessCard, session.clone());
            }

            session
        }
        Some(session) => session.clone(),
    }
}