dachterasse 0.1.4

A crate for scraping the HPI lecture overview site
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

use std::collections::HashMap;
use std::hash::{Hash, Hasher};

#[derive(Serialize, Deserialize, Eq, Debug, Clone)]
pub struct Lecture {
    pub title: String,
    pub url: String,
    // pub description: Option<String>,
    pub categories: Option<HashMap<String, Vec<String>>>,
}

impl PartialEq for Lecture {
    fn eq(&self, other: &Self) -> bool {
        self.url == other.url
    }
}

impl Hash for Lecture {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.url.hash(state);
    }
}

#[derive(Serialize, Deserialize)]
pub enum DegreeLevel {
    Bachelor,
    Master,
}

// TODO: Serialize to commonly used language abbreviations
#[derive(Serialize, Deserialize)]
pub enum Language {
    German,
    English,
}

#[derive(Serialize, Deserialize)]
pub struct StaticDegree {
    /// The section headline string as found in the module overview for a lecture
    pub name: &'static str,
    pub level: DegreeLevel,
    /// Lecture overview site URL for this degree
    pub url: &'static str,
    pub language: Language,
    pub id: &'static str,
}

impl PartialEq for StaticDegree {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl Eq for StaticDegree {}

impl Hash for StaticDegree {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}

pub struct Degrees {
    #[allow(dead_code)]
    no_instance: (),
}
impl Degrees {
    pub const ITSE_BA: StaticDegree = StaticDegree {
        name: "IT-Systems Engineering BA",
        level: DegreeLevel::Bachelor,
        language: Language::German,
        url: "https://hpi.de/studium/im-studium/lehrveranstaltungen/it-systems-engineering-ba.html",
        id: "itse-ba",
    };
    pub const ITSE_MA: StaticDegree = StaticDegree {
        name: "IT-Systems Engineering MA",
        level: DegreeLevel::Master,
        language: Language::German,
        url: "https://hpi.de/studium/im-studium/lehrveranstaltungen/it-systems-engineering-ma.html",
        id: "itse-ma",
    };
    pub const DE_MA: StaticDegree = StaticDegree {
        name: "Data Engineering MA",
        level: DegreeLevel::Master,
        language: Language::German,
        url: "https://hpi.de/studium/im-studium/lehrveranstaltungen/data-engineering-ma.html",
        id: "de-ma",
    };
    pub const DH_MA: StaticDegree = StaticDegree {
        name: "Digital Health MA",
        level: DegreeLevel::Master,
        language: Language::English,
        url: "https://hpi.de/studium/im-studium/lehrveranstaltungen/digital-health-ma.html",
        id: "dh-ma",
    };
    pub const CS_MA: StaticDegree = StaticDegree {
        name: "Cybersecurity MA",
        level: DegreeLevel::Master,
        language: Language::English,
        url: "https://hpi.de/studium/im-studium/lehrveranstaltungen/cybersecurity-ma.html",
        id: "cs-ma",
    };
    pub const SSE_MA: StaticDegree = StaticDegree {
        name: "Software Systems Engineering",
        level: DegreeLevel::Master,
        language: Language::English,
        url: "tbd",
        id: "tbd",
    };

    const DEGREES: &'static [StaticDegree] = &[
        Self::ITSE_BA,
        Self::ITSE_MA,
        Self::DE_MA,
        Self::DH_MA,
        Self::CS_MA,
        // Self::SSE_MA
    ];

    pub fn all() -> &'static [StaticDegree] {
        Self::DEGREES
    }
}

#[derive(Serialize, Deserialize)]
pub struct Degree {
    /// The section headline string as found in the module overview for a lecture
    pub name: String,
    pub level: DegreeLevel,
    /// Lecture overview site URL for this degree
    pub url: String,
    pub language: Language,
    pub id: String,
}

impl PartialEq for Degree {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

impl Eq for Degree {}

impl Hash for Degree {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
    }
}