classcharts/api/
badges.rs

1use serde::Deserialize;
2
3use crate::client::{ErrorResponse, CCParser, SuccessResponse, Client};
4
5use super::helpers::Empty;
6
7#[derive(Deserialize, Debug)]
8pub struct Teacher {
9    pub title: String,
10    pub first_name: String,
11    pub last_name: String,
12}
13
14#[derive(Deserialize, Debug)]
15pub struct LessonPupilBehaviour {
16    pub reason: String,
17    pub score: usize,
18    pub polarity: String,
19    pub timestamp: String,
20    pub teacher: Teacher,
21}
22
23#[derive(Deserialize, Debug)]
24pub struct PupilEvent {
25    pub label: String,
26}
27
28#[derive(Deserialize, Debug)]
29pub struct PupilBadge {
30    pub timestamp: String,
31    pub lesson_pupil_behaviour: LessonPupilBehaviour,
32    pub event: PupilEvent,
33}
34
35#[derive(Deserialize, Debug)]
36pub struct Badge {
37    pub id: usize,
38    pub name: String,
39    pub icon: String,
40    pub colour: String,
41    pub created_date: String,
42    pub pupil_badges: Vec<PupilBadge>,
43    pub icon_url: String,
44}
45
46pub type BadgesData = Vec<Badge>;
47pub type BadgesMeta = Vec<Empty>;
48pub type Badges = SuccessResponse<BadgesData, BadgesMeta>;
49
50impl Client {
51    /// Gets the current student's earned badges 
52    pub async fn get_badges(&mut self) -> Result<Badges, ErrorResponse> {
53        let request = self
54            .build_get(format!("/eventbadges/{}", self.student_id))
55            .await?
56            .send()
57            .await?;
58
59        let text = request.cc_parse().await?;
60        let data: Badges = serde_json::from_str(&text)?;
61
62        return Ok(data);
63    }
64}
65
66#[cfg(test)]
67mod tests {
68    use super::*;
69    use httpmock::prelude::*;
70    use serde_json::json;
71
72    #[tokio::test]
73    async fn get_badges_test() {
74        // Start a lightweight mock server.
75        let server = MockServer::start();
76        // Create a mock on the server.
77        let badges_response = server.mock(|when, then| {
78            when.method(GET)
79                .path("/apiv2student/eventbadges/student_id");
80            then.status(200)
81                .header("content-type", "application/json")
82                .json_body(json!({
83                    "success": 1,
84                    "data": [
85                        {
86                            "id": 59345,
87                            "name": "Test",
88                            "icon": "https://example.com",
89                            "colour": "#000",
90                            "created_date": "2023-08-25T00:00:00+00:00",
91                            "pupil_badges": [{
92                                "timestamp": "2023-08-25T00:00:00+00:00",
93                                "lesson_pupil_behaviour": {
94                                    "reason": "Test",
95                                    "score": 10,
96                                    "polarity": "positive",
97                                    "timestamp": "2023-08-25T00:00:00+00:00",
98                                    "teacher": {
99                                        "title": "Mr",
100                                        "first_name": "first_name",
101                                        "last_name": "last_name",
102                                    },
103                                },
104                                "event": {
105                                    "label": "Test",
106                                },
107                            }],
108                            "icon_url": "https://example.com",
109                        }
110                    ],
111                    "meta": [],
112                }));
113        });
114
115        let mut client = Client::generate_mock(server.base_url());
116
117        let _ = client.get_badges().await.unwrap();
118
119        badges_response.assert();
120    }
121}