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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197

use serde::{self, Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
pub struct Params {
    /// The id of the user who we are viewing conversations for
    #[serde(rename = "userid")]
    pub r#userid: Option<i64>,
    /// The id of the conversation to fetch
    #[serde(rename = "conversationid")]
    pub r#conversationid: Option<i64>,
    /// Include contact requests in the members
    #[serde(rename = "includecontactrequests")]
    pub r#includecontactrequests: Option<bool>,
    /// Include privacy info in the members
    #[serde(rename = "includeprivacyinfo")]
    pub r#includeprivacyinfo: Option<bool>,
    /// Limit for number of members
    #[serde(rename = "memberlimit")]
    pub r#memberlimit: Option<i64>,
    /// Offset for member list
    #[serde(rename = "memberoffset")]
    pub r#memberoffset: Option<i64>,
    /// Limit for number of messages
    #[serde(rename = "messagelimit")]
    pub r#messagelimit: Option<i64>,
    /// Offset for messages list
    #[serde(rename = "messageoffset")]
    pub r#messageoffset: Option<i64>,
    /// Order messages by newest first
    #[serde(rename = "newestmessagesfirst")]
    pub r#newestmessagesfirst: Option<bool>,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct ReturnsMembersItemContactrequestsItem {
    /// The id of the contact request
    #[serde(rename = "id")]
    pub r#id: Option<i64>,
    /// The id of the user who created the contact request
    #[serde(rename = "userid")]
    pub r#userid: Option<i64>,
    /// The id of the user confirming the request
    #[serde(rename = "requesteduserid")]
    pub r#requesteduserid: Option<i64>,
    /// The timecreated timestamp for the contact request
    #[serde(rename = "timecreated")]
    pub r#timecreated: Option<i64>,
}

/// The contact requests
pub type r#ReturnsMembersItemContactrequests = Vec<ReturnsMembersItemContactrequestsItem>;

/// information about conversation
#[derive(Serialize, Deserialize, Debug)]
pub struct ReturnsMembersItemConversationsItem {
    /// Conversations id
    #[serde(rename = "id")]
    pub r#id: Option<i64>,
    /// Conversation type: private or public
    #[serde(rename = "type")]
    pub r#type: Option<i64>,
    /// Multilang compatible conversation name2
    #[serde(rename = "name")]
    pub r#name: Option<String>,
    /// The timecreated timestamp for the conversation
    #[serde(rename = "timecreated")]
    pub r#timecreated: Option<i64>,
}

/// Conversations between users
pub type r#ReturnsMembersItemConversations = Vec<ReturnsMembersItemConversationsItem>;

#[derive(Serialize, Deserialize, Debug)]
pub struct ReturnsMembersItem {
    /// The user id
    #[serde(rename = "id")]
    pub r#id: Option<i64>,
    /// The user's name
    #[serde(rename = "fullname")]
    pub r#fullname: Option<String>,
    /// The link to the user's profile page
    #[serde(rename = "profileurl")]
    pub r#profileurl: Option<String>,
    /// User picture URL
    #[serde(rename = "profileimageurl")]
    pub r#profileimageurl: Option<String>,
    /// Small user picture URL
    #[serde(rename = "profileimageurlsmall")]
    pub r#profileimageurlsmall: Option<String>,
    /// The user's online status
    #[serde(rename = "isonline")]
    pub r#isonline: Option<bool>,
    /// Show the user's online status?
    #[serde(rename = "showonlinestatus")]
    pub r#showonlinestatus: Option<bool>,
    /// If the user has been blocked
    #[serde(rename = "isblocked")]
    pub r#isblocked: Option<bool>,
    /// Is the user a contact?
    #[serde(rename = "iscontact")]
    pub r#iscontact: Option<bool>,
    /// Is the user deleted?
    #[serde(rename = "isdeleted")]
    pub r#isdeleted: Option<bool>,
    /// If the user can still message even if they get blocked
    #[serde(rename = "canmessageevenifblocked")]
    pub r#canmessageevenifblocked: Option<bool>,
    /// If the user can be messaged
    #[serde(rename = "canmessage")]
    pub r#canmessage: Option<bool>,
    /// If the user requires to be contacts
    #[serde(rename = "requirescontact")]
    pub r#requirescontact: Option<bool>,
    /// The contact requests
    #[serde(rename = "contactrequests")]
    pub r#contactrequests: Option<r#ReturnsMembersItemContactrequests>,
    /// Conversations between users
    #[serde(rename = "conversations")]
    pub r#conversations: Option<r#ReturnsMembersItemConversations>,
}

pub type r#ReturnsMembers = Vec<ReturnsMembersItem>;

#[derive(Serialize, Deserialize, Debug)]
pub struct ReturnsMessagesItem {
    /// The id of the message
    #[serde(rename = "id")]
    pub r#id: Option<i64>,
    /// The id of the user who sent the message
    #[serde(rename = "useridfrom")]
    pub r#useridfrom: Option<i64>,
    /// The text of the message
    #[serde(rename = "text")]
    pub r#text: Option<String>,
    /// The timecreated timestamp for the message
    #[serde(rename = "timecreated")]
    pub r#timecreated: Option<i64>,
}

pub type r#ReturnsMessages = Vec<ReturnsMessagesItem>;

#[derive(Serialize, Deserialize, Debug)]
pub struct Returns {
    /// The conversation id
    #[serde(rename = "id")]
    pub r#id: Option<i64>,
    /// The conversation name, if set
    #[serde(rename = "name")]
    pub r#name: Option<String>,
    /// A subtitle for the conversation name, if set
    #[serde(rename = "subname")]
    pub r#subname: Option<String>,
    /// A link to the conversation picture, if set
    #[serde(rename = "imageurl")]
    pub r#imageurl: Option<String>,
    /// The type of the conversation (1=individual,2=group,3=self)
    #[serde(rename = "type")]
    pub r#type: Option<i64>,
    /// Total number of conversation members
    #[serde(rename = "membercount")]
    pub r#membercount: Option<i64>,
    /// If the user muted this conversation
    #[serde(rename = "ismuted")]
    pub r#ismuted: Option<bool>,
    /// If the user marked this conversation as a favourite
    #[serde(rename = "isfavourite")]
    pub r#isfavourite: Option<bool>,
    /// If the user has read all messages in the conversation
    #[serde(rename = "isread")]
    pub r#isread: Option<bool>,
    /// The number of unread messages in this conversation
    #[serde(rename = "unreadcount")]
    pub r#unreadcount: Option<i64>,
    #[serde(rename = "members")]
    pub r#members: Option<r#ReturnsMembers>,
    #[serde(rename = "messages")]
    pub r#messages: Option<r#ReturnsMessages>,
    /// If the user can delete messages in the conversation for all users
    #[serde(rename = "candeletemessagesforallusers")]
    pub r#candeletemessagesforallusers: Option<bool>,
}

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_conversation", 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_conversation", params).await
}