def parse(person_data: dict, person_id: int,
edupage: EdupageModule) -> Optional[EduAccount]:
account_type = EduAccount.recognize_account_type(person_data)
if account_type == EduAccountType.STUDENT:
class_id = ModuleHelper.parse_int(person_data.get("classid"))
name = DbiHelper(edupage).fetch_student_name(person_id)
gender = Gender.parse(person_data.get("gender"))
student_since = ModuleHelper.strptime_or_none(
person_data.get("datefrom"), "%Y-%m-%d")
number_in_class = ModuleHelper.parse_int(
person_data.get("numberinclass"))
ModuleHelper.assert_none(name)
return EduStudent(person_id, name, gender, student_since, class_id,
number_in_class)
elif account_type == EduAccountType.TEACHER:
classroom_id = person_data.get("classroomid")
classroom_name = DbiHelper(edupage).fetch_classroom_number(
classroom_id) if ModuleHelper.parse_int(classroom_id) else ""
name = DbiHelper(edupage).fetch_teacher_name(person_id)
gender = Gender.parse(person_data.get("gender"))
if teacher_since_str := person_data.get("datefrom"):
teacher_since = datetime.strptime(teacher_since_str,
"%Y-%m-%d")
else:
teacher_since = None
if teacher_to_str := person_data.get("dateto"):
teacher_to = datetime.strptime(teacher_to_str, "%Y-%m-%d")
def get_teachers(self) -> Optional[list]:
teachers = DbiHelper(self.edupage).fetch_teacher_list()
if teachers is None:
return None
result = []
for teacher_id_str in teachers:
if not teacher_id_str:
continue
teacher_id = int(teacher_id_str)
teacher_data = teachers.get(teacher_id_str)
teacher = EduAccount.parse(teacher_data, teacher_id, self.edupage)
result.append(teacher)
return result
def get_students(self) -> Optional[list]:
students = DbiHelper(self.edupage).fetch_student_list()
if students is None:
return None
result = []
for student_id_str in students:
if not student_id_str:
continue
student_id = int(student_id_str)
student_data = students.get(student_id_str)
student = EduAccount.parse(student_data, student_id, self.edupage)
result.append(student)
return result
def get_timetable(self, date: datetime) -> Optional[Timetable]:
dp = self.__get_dp()
dates = dp.get("dates")
date_plans = dates.get(date.strftime("%Y-%m-%d"))
if date_plans is None:
raise MissingDataException()
plan = date_plans.get("plan")
lessons = []
for subject in plan:
header = subject.get("header")
if len(header) == 0:
continue
subject_id = int(subject.get("subjectid"))
if subject_id:
subject_name = DbiHelper(
self.edupage).fetch_subject_name(subject_id)
else:
subject_name = header[0].get("text")
teachers = []
teacher_ids = subject.get("teacherids")
if teacher_ids is not None and len(teacher_ids) != 0:
for teacher_id_str in teacher_ids:
if not teacher_id_str:
continue
teacher_id = int(teacher_id_str)
teacher = People(self.edupage).get_teacher(teacher_id)
teachers.append(teacher)
classrooms = []
classroom_ids = subject.get("classroomids")
if classroom_ids is not None and len(classroom_ids) != 0:
for classroom_id_str in classroom_ids:
if not classroom_id_str:
continue
classroom_id = int(classroom_id_str)
classroom_number = DbiHelper(
self.edupage).fetch_classroom_number(classroom_id)
classrooms.append(classroom_number)
start_of_lesson_str = subject.get("starttime")
end_of_lesson_str = subject.get("endtime")
ModuleHelper.assert_none(start_of_lesson_str, end_of_lesson_str)
start_of_lesson = datetime.strptime(start_of_lesson_str, "%H:%M")
end_of_lesson = datetime.strptime(end_of_lesson_str, "%H:%M")
online_lesson_link = subject.get("ol_url")
lesson = Lesson(teachers, classrooms, start_of_lesson,
end_of_lesson, online_lesson_link, subject_id,
subject_name)
lessons.append(lesson)
return Timetable(lessons)
def get_timetable_for_person(self, id: int,
date: datetime) -> List[LessonSkeleton]:
all_teachers = People(self.edupage).get_teachers()
students = People(self.edupage).get_students()
def teacher_by_id(id: int):
filtered = list(filter(lambda x: x.person_id == id, all_teachers))
if not filtered:
raise MissingDataException(
f"Teacher with id {id} doesn't exist!")
return filtered[0]
def student_by_id(id: int):
filtered = list(filter(lambda x: x.person_id == id, students))
if not filtered:
raise MissingDataException(
f"Student with id {id} doesn't exist!")
return filtered[0]
def classroom_by_id(id: int):
return DbiHelper(self.edupage).fetch_classroom_number(id)
table = None
try:
teacher_by_id(id)
table = "teachers"
except:
try:
student_by_id(id)
table = "students"
except:
if classroom_by_id(id):
table = "classrooms"
if not table:
raise MissingDataException(
f"Teacher, student or class with id {id} doesn't exist!")
timetable_data = self.__get_timetable_data(id, table, date)
skeletons = []
for skeleton in timetable_data:
date_str = skeleton.get("date")
date = datetime.strptime(date_str, "%Y-%m-%d")
start_time_str = skeleton.get("starttime")
start_time_dt = datetime.strptime(start_time_str, "%H:%M")
start_time = time(start_time_dt.hour, start_time_dt.minute)
end_time_str = skeleton.get("endtime")
end_time_dt = datetime.strptime(end_time_str, "%H:%M")
end_time = time(end_time_dt.hour, end_time_dt.minute)
subject_id_str = skeleton.get("subjectid")
subject_id = int(
subject_id_str) if subject_id_str.isdigit() else None
subject_name = None
if subject_id is not None:
subject_name = DbiHelper(
self.edupage).fetch_subject_name(subject_id)
classes = [int(id) for id in skeleton.get("classids")]
groups = skeleton.get("groupnames")
teachers = [
teacher_by_id(int(id)) for id in skeleton.get("teacherids")
]
classrooms = [
classroom_by_id(int(id)) for id in skeleton.get("classroomids")
]
duration = (skeleton.get("durationperiods")
if skeleton.get("durationperiods") is not None else 1)
new_skeleton = LessonSkeleton(date.weekday(), start_time, end_time,
subject_id, subject_name, classes,
groups, classrooms, duration,
teachers)
skeletons.append(new_skeleton)
return skeletons
def classroom_by_id(id: int):
return DbiHelper(self.edupage).fetch_classroom_number(id)
def get_grades(self) -> list[EduGrade]:
grade_data = self.__get_grade_data()
grades = grade_data.get("vsetkyZnamky")
grade_details = grade_data.get("vsetkyUdalosti").get("edupage")
output = []
for grade in grades:
# ID
event_id_str = grade.get("udalostid")
if not event_id_str:
continue
event_id = int(event_id_str)
# Title
details = grade_details.get(event_id_str)
title = details.get("p_meno")
# Grade
grade_raw = grade.get("data").split(" (", 1)
grade_n = float(grade_raw[0])
try:
comment = grade_raw[1].rsplit(")", 1)[0]
except IndexError:
comment = None
# Date
date_str = grade.get("datum")
date = datetime.strptime(date_str, "%Y-%m-%d %H:%M:%S")
# Subject ID and name
subject_id_str = details.get("PredmetID")
if subject_id_str is None or subject_id_str == "vsetky":
continue
subject_id = int(subject_id_str)
subject_name = DbiHelper(self.edupage).fetch_subject_name(subject_id)
# Teacher
teacher_id_str = details.get("UcitelID")
if teacher_id_str is None:
teacher = None
else:
teacher_id = int(teacher_id_str)
teacher_data = DbiHelper(self.edupage).fetch_teacher_data(teacher_id)
teacher = EduTeacher.parse(teacher_data, teacher_id, self.edupage)
# Maximal points and importance
grade_type = details.get("p_typ_udalosti")
if grade_type == "1":
# Normal grade (1 – 5)
max_points = None
importance = float(details.get("p_vaha")) / 20
elif grade_type == "2":
# Points grade (in points – e.g. 0 – 20 points)
max_points = int(details.get("p_vaha"))
importance = None
elif grade_type == "3":
# Percental grade (0 – 100 %)
max_points = int(details.get("p_vaha_body"))
importance = float(details.get("p_vaha")) / 20
# Verbal and percents
try:
verbal = False
if max_points:
percent = round(float(grade_n) / float(max_points) * 100, 2)
elif max_points == 0:
percent = float("inf")
else:
percent = None
except:
verbal = True
grade = EduGrade(event_id, title, grade_n, comment, date, subject_id,
subject_name, teacher, max_points, importance, verbal, percent)
output.append(grade)
return output
def get_notifications(self):
output = []
timeline_items = self.edupage.data.get("items")
for event in timeline_items:
event_id_str = event.get("timelineid")
if not event_id_str:
continue
event_id = int(event_id_str)
event_data = json.loads(event.get("data"))
event_type_str = event.get("typ")
if not event_id_str:
continue
event_type = EventType.parse(event_type_str)
if event_type is None:
print(event_type_str)
event_timestamp = datetime.strptime(event.get("timestamp"),
"%Y-%m-%d %H:%M:%S")
text = event.get("text")
# what about different languages?
# for message event type
if text.startswith("Dôležitá správa"):
text = event_data.get("messageContent")
if text == "":
try:
text = event_data.get("nazov")
except:
text = ""
# todo: add support for "*"
recipient_name = event.get("user_meno")
recipient_data = DbiHelper(
self.edupage).fetch_person_data_by_name(recipient_name)
if recipient_name in ["*", "Celá škola"]:
recipient = "*"
elif type(recipient_name) == str:
recipient = recipient_name
else:
ModuleHelper.assert_none(recipient_data)
recipient = EduAccount.parse(recipient_data,
recipient_data.get("id"),
self.edupage)
# todo: add support for "*"
author_name = event.get("vlastnik_meno")
author_data = DbiHelper(
self.edupage).fetch_person_data_by_name(author_name)
if author_name == "*":
author = "*"
elif type(author_name) == str:
author = author_name
else:
ModuleHelper.assert_none(author_data)
author = EduAccount.parse(author_data, author_data.get("id"),
self.edupage)
additional_data = event.get("data")
if additional_data and type(additional_data) == str:
additional_data = json.loads(additional_data)
event = TimelineEvent(event_id, event_timestamp, text, author,
recipient, event_type, additional_data)
output.append(event)
return output
def get_student(self, student_id: int) -> Optional[EduStudent]:
student_data = DbiHelper(self.edupage).fetch_student_data(student_id)
if student_data is None:
return None
return EduAccount.parse(student_data, student_id, self.edupage)
def get_teacher(self, teacher_id: int) -> Optional[EduTeacher]:
teacher_data = DbiHelper(self.edupage).fetch_teacher_data(teacher_id)
if teacher_data is None:
return None
return EduAccount.parse(teacher_data, teacher_id, self.edupage)