rusaint 0.16.2

Easy-to-use SSU u-saint client
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
135
136
137
138

use crate::get_session;
use lazy_static::lazy_static;
use rusaint::{
    RusaintError, application::student_information::StudentInformationApplication,
    client::USaintClientBuilder,
};
use std::sync::{Arc, OnceLock};
use tokio::sync::{Mutex, RwLock};
use tracing_test::traced_test;
use wdpe::error::{ElementError, WebDynproError};

lazy_static! {
    static ref APP: Mutex<OnceLock<Arc<RwLock<StudentInformationApplication>>>> =
        Mutex::new(OnceLock::new());
}

async fn get_app() -> Result<Arc<RwLock<StudentInformationApplication>>, RusaintError> {
    let app_lock = APP.lock().await;
    if let Some(lock) = app_lock.get() {
        Ok(lock.clone())
    } else {
        let session = get_session().await.unwrap().clone();
        app_lock
            .set(Arc::new(RwLock::new(
                USaintClientBuilder::new()
                    .session(session)
                    .build_into()
                    .await?,
            )))
            .unwrap();
        Ok(app_lock.get().unwrap().clone())
    }
}

#[tokio::test]
#[traced_test]
async fn general() {
    let lock = get_app().await.unwrap();
    let app = lock.read().await;
    let student_info = app.general().unwrap();
    tracing::info!("{:?}", student_info);
}

#[tokio::test]
#[traced_test]
async fn graduation() {
    let lock = get_app().await.unwrap();
    let app = lock.read().await;
    let student_info = app.graduation();
    match student_info {
        Err(RusaintError::WebDynproError(WebDynproError::Element(ref el_err))) => {
            match el_err.as_ref() {
                ElementError::NoSuchContent {
                    element: _,
                    content: _,
                } => (),
                _ => panic!("{el_err:?}"),
            }
        }
        Err(err) => {
            panic!("{err:?}");
        }
        Ok(_) => (),
    }
    tracing::info!("{:?}", student_info);
}

#[tokio::test]
#[traced_test]
async fn qualifications() {
    let lock = get_app().await.unwrap();
    let app = lock.read().await;
    let student_info = app.qualifications();
    tracing::info!("{:?}", student_info);
}

#[tokio::test]
#[traced_test]
async fn work() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let student_info = app.work().await.unwrap();
    tracing::info!("{:?}", student_info);
}

#[tokio::test]
#[traced_test]
async fn family() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let student_info = app.family().await.unwrap();
    tracing::info!("{:?}", student_info);
}

#[tokio::test]
#[traced_test]
async fn religion() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let student_info = app.religion().await.unwrap();
    tracing::info!("{:?}", student_info);
}

#[tokio::test]
#[traced_test]
async fn transfer() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let student_info = app.transfer().await.unwrap();
    tracing::info!("{:?}", student_info);
}

#[tokio::test]
#[traced_test]
async fn bank_account() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let student_info = app.bank_account().await.unwrap();
    tracing::info!("{:?}", student_info);
}

#[tokio::test]
#[traced_test]
async fn academic_record() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let student_info = app.academic_record().await.unwrap();
    tracing::info!("{:?}", student_info);
}

#[tokio::test]
#[traced_test]
async fn research_bank_account() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let student_info = app.research_bank_account().await.unwrap();
    tracing::info!("{:?}", student_info);
}