moodle_api 0.1.0

Moodle Webservice Client 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
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 serde::{self, Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
pub struct Params {
    /// the user id who received the message, 0 for any user
    #[serde(rename = "useridto")]
    pub r#useridto: Option<i64>,
    /// the user id who send the message, 0 for any user. -10 or -20 for no-reply or support user
    #[serde(rename = "useridfrom")]
    pub r#useridfrom: Option<i64>,
    /// type of message to return, expected values are: notifications, conversations and both
    #[serde(rename = "type")]
    pub r#type: Option<String>,
    /// 1 for getting read messages, 0 for unread, 2 for both
    #[serde(rename = "read")]
    pub r#read: Option<i64>,
    /// true for ordering by newest first, false for oldest first
    #[serde(rename = "newestfirst")]
    pub r#newestfirst: Option<bool>,
    /// limit from
    #[serde(rename = "limitfrom")]
    pub r#limitfrom: Option<i64>,
    /// limit number
    #[serde(rename = "limitnum")]
    pub r#limitnum: Option<i64>,
}

/// message
#[derive(Serialize, Deserialize, Debug)]
pub struct ReturnsMessagesItem {
    /// Message id
    #[serde(rename = "id")]
    pub r#id: Option<i64>,
    /// User from id
    #[serde(rename = "useridfrom")]
    pub r#useridfrom: Option<i64>,
    /// User to id
    #[serde(rename = "useridto")]
    pub r#useridto: Option<i64>,
    /// The message subject
    #[serde(rename = "subject")]
    pub r#subject: Option<String>,
    /// The message text formated
    #[serde(rename = "text")]
    pub r#text: Option<String>,
    /// The message
    #[serde(rename = "fullmessage")]
    pub r#fullmessage: Option<String>,
    /// fullmessage format (1 = HTML, 0 = MOODLE, 2 = PLAIN, or 4 = MARKDOWN
    #[serde(rename = "fullmessageformat")]
    pub r#fullmessageformat: Option<i64>,
    /// The message in html
    #[serde(rename = "fullmessagehtml")]
    pub r#fullmessagehtml: Option<String>,
    /// The shorten message
    #[serde(rename = "smallmessage")]
    pub r#smallmessage: Option<String>,
    /// Is a notification?
    #[serde(rename = "notification")]
    pub r#notification: Option<i64>,
    /// Context URL
    #[serde(rename = "contexturl")]
    pub r#contexturl: Option<String>,
    /// Context URL link name
    #[serde(rename = "contexturlname")]
    pub r#contexturlname: Option<String>,
    /// Time created
    #[serde(rename = "timecreated")]
    pub r#timecreated: Option<i64>,
    /// Time read
    #[serde(rename = "timeread")]
    pub r#timeread: Option<i64>,
    /// User to full name
    #[serde(rename = "usertofullname")]
    pub r#usertofullname: Option<String>,
    /// User from full name
    #[serde(rename = "userfromfullname")]
    pub r#userfromfullname: Option<String>,
    /// The component that generated the notification
    #[serde(rename = "component")]
    pub r#component: Option<String>,
    /// The type of notification
    #[serde(rename = "eventtype")]
    pub r#eventtype: Option<String>,
    /// Custom data to be passed to the message processor. The data here is serialised using json_encode().
    #[serde(rename = "customdata")]
    pub r#customdata: Option<String>,
    /// URL for icon, only for notifications.
    #[serde(rename = "iconurl")]
    pub r#iconurl: Option<String>,
}

pub type r#ReturnsMessages = Vec<ReturnsMessagesItem>;

/// warning
#[derive(Serialize, Deserialize, Debug)]
pub struct ReturnsWarningsItem {
    /// item
    #[serde(rename = "item")]
    pub r#item: Option<String>,
    /// item id
    #[serde(rename = "itemid")]
    pub r#itemid: Option<i64>,
    /// the warning code can be used by the client app to implement specific behaviour
    #[serde(rename = "warningcode")]
    pub r#warningcode: Option<String>,
    /// untranslated english message to explain the warning
    #[serde(rename = "message")]
    pub r#message: Option<String>,
}

/// list of warnings
pub type r#ReturnsWarnings = Vec<ReturnsWarningsItem>;

#[derive(Serialize, Deserialize, Debug)]
pub struct Returns {
    #[serde(rename = "messages")]
    pub r#messages: Option<r#ReturnsMessages>,
    /// list of warnings
    #[serde(rename = "warnings")]
    pub r#warnings: Option<r#ReturnsWarnings>,
}

pub async fn call<'a>(
    client: &'a mut moodle_client::MoodleClient,
    params: &'a mut Params,
) -> anyhow::Result<Returns> {
    let json = client.post("core_message_get_messages", params).await?;

    serde_json::from_value(json).map_err(|e| e.into())
}

pub async fn call_raw<'a>(
    client: &'a mut moodle_client::MoodleClient,
    params: &'a mut Params,
) -> anyhow::Result<serde_json::Value> {
    client.post("core_message_get_messages", params).await
}