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

use serde::{Deserialize, Serialize};

use super::Fetchable;
use crate::entities::{CourseId, EntityType, Module, Room, Staff, Unknown, UnknownId};

#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SideBarEvent {
    pub federation_id: UnknownId,
    pub entity_type: Unknown,
    pub elements: Vec<SideBarEventElement>,
}

#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct RawSideBarEventElement<T: EntityType> {
    pub content: Option<String>,
    #[serde(bound(deserialize = "T: EntityType"))]
    pub federation_id: T::Id,
    #[serde(bound(deserialize = "T: EntityType"))]
    pub entity_type: T,
    pub assignment_context: Option<String>,
    pub contains_hyperlinks: bool,
    pub is_notes: bool,
    pub is_student_specific: bool,
}

#[derive(Debug, Clone, PartialEq, Deserialize)]
#[serde(tag = "label")]
pub enum SideBarEventElement {
    Time(RawSideBarEventElement<Unknown>),
    #[serde(rename = "Catégorie")]
    Category(RawSideBarEventElement<Unknown>),
    #[serde(rename = "Matière")]
    Module(RawSideBarEventElement<Module>),
    #[serde(rename = "Salle")]
    Room(RawSideBarEventElement<Room>),
    #[serde(rename = "Enseignant")]
    Teacher(RawSideBarEventElement<Staff>),
    #[serde(rename = "Notes")]
    Grades(RawSideBarEventElement<Unknown>),
    Name(RawSideBarEventElement<Unknown>),
}

#[derive(Debug, Clone, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct SideBarEventRequest {
    pub event_id: CourseId,
}

impl Fetchable for SideBarEvent {
    type Request = SideBarEventRequest;

    const METHOD_NAME: &'static str = "GetSideBarEvent";
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::entities::RoomId;
    use serde_json::{from_value, json};

    #[test]
    fn deserialize_side_bar_event_element() {
        assert_eq!(
            from_value::<SideBarEventElement>(json!({
                "label": "Time",
                "content": "9/6/2021 8:30 AM-11:45 AM",
                "federationId": null,
                "entityType": 0,
                "assignmentContext": null,
                "containsHyperlinks": false,
                "isNotes": false,
                "isStudentSpecific": false
            }))
            .unwrap(),
            SideBarEventElement::Time(RawSideBarEventElement {
                content: Some("9/6/2021 8:30 AM-11:45 AM".to_owned()),
                federation_id: UnknownId,
                entity_type: Unknown,
                assignment_context: None,
                contains_hyperlinks: false,
                is_notes: false,
                is_student_specific: false,
            })
        );
        assert_eq!(
            from_value::<SideBarEventElement>(json!({
                "label": "Salle",
                "content": "CHE2 Larousse haut AMPHITHÉÂTRE 673p",
                "federationId": "1042721",
                "entityType": 102,
                "assignmentContext": "a-start-end",
                "containsHyperlinks": false,
                "isNotes": false,
                "isStudentSpecific": false
            }))
            .unwrap(),
            SideBarEventElement::Room(RawSideBarEventElement {
                content: Some("CHE2 Larousse haut AMPHITHÉÂTRE 673p".to_owned()),
                federation_id: RoomId("1042721".to_owned()),
                entity_type: Room,
                assignment_context: Some("a-start-end".to_owned()),
                contains_hyperlinks: false,
                is_notes: false,
                is_student_specific: false,
            })
        );
    }

    #[test]
    fn deserialize_side_bar_event() {
        from_value::<SideBarEvent>(json!({
            "federationId": null,
            "entityType": 0,
            "elements": []
        }))
        .unwrap();
    }
}