mirror of https://github.com/stijndcl/didier
354 lines
11 KiB
Python
354 lines
11 KiB
Python
from abc import ABC, abstractmethod
|
|
from dacite import from_dict
|
|
from dataclasses import dataclass, field
|
|
from datetime import datetime, timedelta
|
|
from discord import Colour, Embed
|
|
from enums.platform import Platform, get_platform
|
|
from functions.timeFormatters import fromArray, intToWeekday, timeFromInt
|
|
import json
|
|
from typing import Dict, Optional, List
|
|
|
|
|
|
@dataclass
|
|
class Holiday:
|
|
start_date: List[int]
|
|
end_date: List[int]
|
|
start_date_parsed: datetime = field(init=False)
|
|
end_date_parsed: datetime = field(init=False)
|
|
duration: timedelta = field(init=False)
|
|
|
|
def __post_init__(self):
|
|
self.start_date_parsed = fromArray(self.start_date)
|
|
self.end_date_parsed = fromArray(self.end_date)
|
|
self.duration = self.end_date_parsed - self.start_date_parsed
|
|
|
|
def has_passed(self, current_day: datetime) -> bool:
|
|
"""
|
|
Check if a holiday has passed already
|
|
"""
|
|
return current_day > self.end_date_parsed
|
|
|
|
|
|
@dataclass
|
|
class Course:
|
|
name: str
|
|
|
|
def __str__(self):
|
|
return self.name
|
|
|
|
|
|
@dataclass
|
|
class Location:
|
|
campus: str
|
|
building: str
|
|
room: str
|
|
|
|
def __str__(self):
|
|
return f"{self.campus} {self.building} {self.room}"
|
|
|
|
|
|
@dataclass
|
|
class Timeslot:
|
|
course: Course
|
|
start_time: int
|
|
end_time: int
|
|
canceled: bool = False
|
|
is_special: bool = False
|
|
location: Optional[Location] = None
|
|
online_link: Optional[str] = None
|
|
online_platform: Optional[Platform] = None
|
|
|
|
def __str__(self):
|
|
time_str = f"{timeFromInt(self.start_time)} - {timeFromInt(self.end_time)}"
|
|
|
|
return f"{time_str}: {self.course} {self._get_location_str()}"
|
|
|
|
def get_link_str(self) -> Optional[str]:
|
|
if self.online_link is None or self.online_platform is None:
|
|
return None
|
|
|
|
return f"[{self.online_platform.value.get('name')}]({self.online_link})"
|
|
|
|
def _get_location_str(self, offline_prefix="in", online_prefix="**online** @") -> str:
|
|
return f"{offline_prefix} {self.location}" if self.location is not None \
|
|
else f"{online_prefix} **{self.get_link_str()}**"
|
|
|
|
def get_special_fmt_str(self) -> Optional[str]:
|
|
if not self.canceled and not self.is_special:
|
|
return None
|
|
|
|
# This class was canceled
|
|
if self.canceled:
|
|
return f"{self.course} van {timeFromInt(self.start_time)} gaat vandaag **niet** door."
|
|
|
|
# Something else is wrong
|
|
return f"{self.course} gaat vandaag door van **{timeFromInt(self.start_time)}** tot " \
|
|
f"**{timeFromInt(self.end_time)}** {self._get_location_str(online_prefix='op')}"
|
|
|
|
@staticmethod
|
|
def from_slot_dict(slot_dict: Dict, course_dict: Dict, current_week: int):
|
|
"""
|
|
Construct a Timeslot from a dict of data
|
|
"""
|
|
special = False
|
|
|
|
if "weeks" in slot_dict and str(current_week) in slot_dict["weeks"]:
|
|
# If at least one thing was changed, this slot requires extra attention
|
|
special = True
|
|
# Overwrite the normal data with the customized entries
|
|
slot_dict.update(slot_dict["weeks"][str(current_week)])
|
|
|
|
# Only happens online, not on-campus
|
|
online_only = slot_dict["weeks"][str(current_week)].get("online_only", False)
|
|
if online_only:
|
|
slot_dict.pop("location")
|
|
|
|
course = Course(course_dict["course"])
|
|
start_time = slot_dict["time"]["start"]
|
|
end_time = slot_dict["time"]["end"]
|
|
|
|
# Location can be none if a class is online-only
|
|
location = from_dict(Location, slot_dict["location"]) if "location" in slot_dict else None
|
|
|
|
# Find platform & link if this class is online
|
|
online_platform: Platform = get_platform(slot_dict.get("online", None))
|
|
|
|
# Custom online link for this day if it exists, else the general link for this platform
|
|
online_link = \
|
|
slot_dict["online_link"] if "online_link" in slot_dict else \
|
|
course_dict["online_links"][online_platform.value["rep"]] \
|
|
if online_platform is not None \
|
|
else None
|
|
|
|
return Timeslot(course=course, start_time=start_time, end_time=end_time, canceled="canceled" in slot_dict,
|
|
is_special=special, location=location, online_platform=online_platform, online_link=online_link)
|
|
|
|
|
|
@dataclass
|
|
class Schedule:
|
|
day: datetime
|
|
year: int
|
|
semester: int
|
|
targeted_weekday: bool = False
|
|
week: int = field(init=False)
|
|
schedule_dict: Dict = field(init=False)
|
|
start_date: datetime = field(init=False)
|
|
end_date: datetime = field(init=False)
|
|
semester_over: bool = False
|
|
holiday_offset: int = 0
|
|
current_holiday: Optional[Holiday] = None
|
|
weekday_str: str = field(init=False)
|
|
|
|
def __post_init__(self):
|
|
self.schedule_dict: Dict = self.load_schedule_file()
|
|
self.start_date = fromArray(self.schedule_dict["semester_start"])
|
|
self.end_date = fromArray(self.schedule_dict["semester_end"])
|
|
|
|
# Semester is over
|
|
if self.end_date < self.day:
|
|
self.semester_over = True
|
|
return
|
|
|
|
self.check_holidays()
|
|
self.week = self.get_week()
|
|
|
|
# # Store the target weekday (in case it exists) so we can ask for the next
|
|
# # friday after the holiday, for example
|
|
# target_weekday = -1 if not self.targeted_weekday else self.day.weekday()
|
|
#
|
|
# # Show schedule for after holidays
|
|
# if self.current_holiday is not None:
|
|
# # Set day to day after holiday
|
|
# self.day = self.current_holiday.end_date_parsed + timedelta(days=1)
|
|
#
|
|
# # Find the next [DAY] after the holidays
|
|
# if target_weekday != -1:
|
|
# self.day = forward_to_weekday(self.day, target_weekday)
|
|
|
|
self.weekday_str = intToWeekday(self.day.weekday())
|
|
|
|
def check_holidays(self):
|
|
"""
|
|
Do all holiday-related stuff here to avoid multiple loops
|
|
"""
|
|
for hol_entry in self.schedule_dict.get("holidays", []):
|
|
holiday: Holiday = from_dict(Holiday, hol_entry)
|
|
|
|
# Hasn't happened yet, don't care
|
|
if holiday.start_date_parsed > self.day:
|
|
continue
|
|
|
|
# In the past: add the offset
|
|
if holiday.has_passed(self.day):
|
|
# Add 1 because Monday-Sunday is only 6 days, but should be counted as a week
|
|
self.holiday_offset += (holiday.duration.days + 1) // 7
|
|
elif holiday.start_date_parsed <= self.day <= holiday.end_date_parsed:
|
|
self.current_holiday = holiday
|
|
|
|
def load_schedule_file(self) -> Dict:
|
|
"""
|
|
Load the schedule from the JSON file
|
|
"""
|
|
with open(f"files/schedules/{self.year}{self.semester}.json", "r") as fp:
|
|
return json.load(fp)
|
|
|
|
def get_week(self) -> int:
|
|
"""
|
|
Get the current week of the semester
|
|
"""
|
|
diff: timedelta = self.day - self.start_date
|
|
|
|
# Hasn't started yet, show week 1
|
|
if diff.days < 0:
|
|
return 1
|
|
|
|
# Add +1 at the end because week 1 would be 0 as it's not over yet
|
|
# Every week would be one behind
|
|
# Also subtract all passed holidays
|
|
return (diff.days // 7) - self.holiday_offset + 1
|
|
|
|
def find_slots_for_course(self, course_dict: Dict) -> List[Timeslot]:
|
|
"""
|
|
Create time timeslots for a course
|
|
"""
|
|
slots_today = []
|
|
|
|
# First create a list of all slots of today
|
|
for slot in course_dict["slots"]:
|
|
# This slot is for a different day
|
|
if slot["time"]["day"] != self.weekday_str.lower():
|
|
continue
|
|
|
|
slots_today.append(slot)
|
|
|
|
# Create Timeslots
|
|
slots_today = list(map(lambda x: Timeslot.from_slot_dict(x, course_dict, self.week), slots_today))
|
|
|
|
return slots_today
|
|
|
|
def create_schedule(self):
|
|
"""
|
|
Create the schedule for the current week
|
|
"""
|
|
if self.current_holiday is not None:
|
|
return HolidayEmbed(self)
|
|
|
|
slots: List[List[Timeslot]] = [self.find_slots_for_course(course) for course in self.schedule_dict["schedule"]]
|
|
slots_flattened = [item for sublist in slots for item in sublist]
|
|
|
|
# Sort by timestamp
|
|
slots_flattened.sort(key=lambda x: x.start_time)
|
|
not_canceled = list(filter(lambda x: not x.canceled, slots_flattened))
|
|
|
|
# All classes are canceled
|
|
if not not_canceled:
|
|
return NoClassEmbed(self, slots_flattened)
|
|
|
|
return ScheduleEmbed(self, slots_flattened, not_canceled)
|
|
|
|
|
|
@dataclass
|
|
class LesEmbed(ABC):
|
|
"""
|
|
Abstract base class for Les embeds
|
|
"""
|
|
schedule: Schedule
|
|
|
|
def get_author(self) -> str:
|
|
level = "Bachelor" if self.schedule.year < 4 else "Master"
|
|
year = self.schedule.year if self.schedule.year < 4 else self.schedule.year - 3
|
|
suffix = "ste" if self.schedule.year == 1 else "de"
|
|
return f"Lessenrooster voor {year}{suffix} {level}"
|
|
|
|
def get_title(self) -> str:
|
|
date = self.schedule.day.strftime("%d/%m/%Y")
|
|
return f"{self.schedule.weekday_str} {date}"
|
|
|
|
def get_footer(self) -> str:
|
|
return f"Semester {self.schedule.semester} | Lesweek {self.schedule.week}"
|
|
|
|
def get_extras(self) -> str:
|
|
return ""
|
|
|
|
def get_online_links(self) -> str:
|
|
return ""
|
|
|
|
@abstractmethod
|
|
def get_description(self) -> str:
|
|
pass
|
|
|
|
def to_embed(self) -> Embed:
|
|
embed = Embed(title=self.get_title(), colour=Colour.blue())
|
|
embed.set_author(name=self.get_author())
|
|
embed.set_footer(text=self.get_footer())
|
|
|
|
embed.description = self.get_description()
|
|
|
|
# Add links if there are any
|
|
links = self.get_online_links()
|
|
if links:
|
|
embed.add_field(name="Online links", value=links, inline=False)
|
|
|
|
# Add extras if there are any
|
|
extras = self.get_extras()
|
|
if extras:
|
|
embed.add_field(name="Extra", value=extras, inline=False)
|
|
|
|
return embed
|
|
|
|
|
|
@dataclass
|
|
class HolidayEmbed(LesEmbed):
|
|
"""
|
|
Class for a Les embed sent during holidays
|
|
"""
|
|
def get_description(self) -> str:
|
|
date = self.schedule.current_holiday.end_date_parsed.strftime("%d/%m/%Y")
|
|
return f"Het is momenteel **vakantie** tot en met **{date}**."
|
|
|
|
|
|
@dataclass
|
|
class NoClassEmbed(LesEmbed):
|
|
"""
|
|
Class for a Les embed when all classes are canceled or there are none at all
|
|
"""
|
|
slots: List[Timeslot]
|
|
|
|
def get_description(self) -> str:
|
|
return "Geen les"
|
|
|
|
def get_extras(self) -> str:
|
|
canceled = list(filter(lambda x: x.canceled, self.slots))
|
|
if not canceled:
|
|
return ""
|
|
|
|
return "\n".join(list(entry.get_special_fmt_str() for entry in canceled))
|
|
|
|
|
|
@dataclass
|
|
class ScheduleEmbed(LesEmbed):
|
|
"""
|
|
Class for a successful schedule
|
|
"""
|
|
slots: List[Timeslot]
|
|
slots_not_canceled: List[Timeslot]
|
|
|
|
def get_description(self) -> str:
|
|
return "\n".join(list(f"{entry}" for entry in self.slots_not_canceled))
|
|
|
|
def get_extras(self) -> str:
|
|
special = list(filter(lambda x: x.is_special or x.canceled, self.slots))
|
|
|
|
if not special:
|
|
return ""
|
|
|
|
return "\n".join(list(entry.get_special_fmt_str() for entry in special))
|
|
|
|
def get_online_links(self) -> str:
|
|
has_link = list(filter(lambda x: x.online_link is not None, self.slots))
|
|
|
|
if not has_link:
|
|
return ""
|
|
|
|
return "\n".join(list(f"{entry.course}: **{entry.get_link_str()}**" for entry in has_link))
|