wikijs 0.2.1

API bindings, CLI client and FUSE filesystem for Wiki.js written in Rust.
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

use serde::{Deserialize, Serialize};

pub type Boolean = bool;
pub type Int = i64;
pub type Date = String;

#[derive(Clone, Deserialize, Debug)]
pub struct KeyValuePair {
    pub key: String,
    pub value: String,
}

#[derive(Clone, Serialize, Debug)]
pub struct KeyValuePairInput {
    pub key: String,
    pub value: String,
}

#[derive(Clone, Deserialize, Debug)]
#[allow(unused)]
pub struct ResponseStatus {
    pub succeeded: Boolean,
    #[serde(rename = "errorCode")]
    pub error_code: Int,
    pub slug: String,
    pub message: Option<String>,
}

pub(crate) trait UnknownError {
    fn unknown_error_code(code: i64, message: String) -> Self;
    fn unknown_error_message(message: String) -> Self;
    fn unknown_error() -> Self;
}

pub(crate) trait KnownErrorCodes {
    fn known_error_codes() -> Vec<i64>;
    fn is_known_error_code(code: i64) -> bool;
}

pub(crate) fn classify_response_error<E: UnknownError + From<i64>>(
    response_errors: Option<Vec<graphql_client::Error>>,
) -> E {
    if let Some(errors) = response_errors {
        if !errors.is_empty() {
            let error = errors[0].clone();
            if let Some(extensions) = error.extensions {
                if extensions.contains_key("exception") {
                    let exception = extensions.get("exception").unwrap();
                    if exception.get("code").is_some() {
                        let code = exception.get("code").unwrap();
                        return code.as_i64().unwrap().into();
                    }
                }
            }
            return E::unknown_error_message(error.message);
        }
    }
    E::unknown_error()
}

pub(crate) fn classify_response_status_error<
    E: UnknownError + KnownErrorCodes + From<i64>,
>(
    response_status: ResponseStatus,
) -> E {
    if !E::is_known_error_code(response_status.error_code) {
        if let Some(message) = response_status.message {
            return E::unknown_error_code(response_status.error_code, message);
        }
    }
    response_status.error_code.into()
}