zermelo-api-vogk 0.2.16__py3-none-any.whl

zermelo_api/__init__.py

@@ -0,0 +1,8 @@
+from .src.zermelo_api import ZermeloAPI
+from .src.branches import Branch, Branches
+from .src.time_utils import *
+from .src.users import Leerling, Medewerker, Leerlingen, Personeel
+from .src.lesgroepen import Lesgroepen, Lesgroep
+from .src.leerjaren import Leerjaar, Leerjaren
+from .src.appointments import get_user_appointments, get_department_updates, Appointment
+from .src.vakken import Vakken, Vak

zermelo_api/src/appointments.py

@@ -0,0 +1,92 @@
+from .zermelo_api import zermelo, from_zermelo_dict
+from dataclasses import dataclass, InitVar, field
+from logger import makeLogger, DEBUG
+
+logger = makeLogger("APPS")
+
+
+@dataclass
+class Appointment:
+    id: int
+    appointmentInstance: int = 0
+    start: int = 0
+    end: int = 0
+    startTimeSlot: int = 0
+    endTimeSlot: int = 0
+    branch: int = 0
+    type: str = "unknown"
+    groupsInDepartments: list[int] = field(default_factory=list)
+    locationsOfBranch: list[int] = field(default_factory=list)
+    locations: list[str] = field(default_factory=list)
+    optional: bool = False
+    valid: bool = False
+    cancelled: bool = False
+    cancelledReason: str = ""
+    modified: bool = False
+    teacherChanged: bool = False
+    groupChanged: bool = False
+    locationChanged: bool = False
+    timeChanged: bool = False
+    moved: bool = False
+    created: int = 0
+    hidden: bool = False
+    commonSchedule: bool = False
+    ignoreSubstitutions: bool = False
+    changeDescription: str = ""
+    schedulerRemark: str = ""
+    capacity: int = 0
+    content: str = ""
+    lastModified: int = 0
+    new: bool = True
+    choosableInDepartments: list[int] = field(default_factory=list)
+    choosableInDepartmentCodes: list[str] = field(default_factory=list)
+    courses: list[int] = field(default_factory=list)
+    alternativeSubject: str = ""
+    onlineStudents: list[str] = field(default_factory=list)
+    extraStudentSource: str = ""
+    appointmentLastModified: int = 0
+    onlineLocationUrl: str = ""
+    remark: str = ""
+    capacityManually: bool = False
+    teachingTimeManually: bool = False
+    teachingTime: int = 0
+    expectedStudentCount: int = 0
+    expectedStudentCountOnline: int = 0
+    availableSpace: int = 0
+    udmUUID: str = ""
+    creator: str = ""
+    subjects: list[str] = field(default_factory=list)
+    teachers: list[int] = field(default_factory=list)
+    onlineTeachers: list[str] = field(default_factory=list)
+    students: list[str] = field(default_factory=list)
+
+    # doesn't work (not enough rights)
+    # @classmethod
+    # def get_appointment(cls, id: int):
+    #     query = f"appointments/{id}"
+    #     status, data = zermelo.getData(query, from_id=True)
+    #     if status != 200:
+    #         raise Exception(data)
+    #     return from_zermelo_dict(cls, data[0])
+
+
+def get_appointments(query: str) -> list[Appointment]:
+    status, data = zermelo.getData(query)
+    if status != 200:
+        raise Exception(data)
+    return [from_zermelo_dict(Appointment, row) for row in data]
+
+
+def get_user_appointments(user: int | str, **kwargs) -> list[Appointment]:
+    query = f"appointments/?user={user}"
+    for key, val in kwargs.items():
+        query += f"&{key}={val}"
+    logger.debug(query)
+    return get_appointments(query)
+
+
+def get_department_updates(id: int, **kwargs) -> list[Appointment]:
+    query = f"appointments/?containsStudentsFromGroupInDepartment={id}"
+    for key, val in kwargs.items():
+        query += f"&{key}={val}"
+    return get_appointments(query)

zermelo_api/src/branches.py

@@ -0,0 +1,93 @@
+from .logger import makeLogger
+from .zermelo_api import ZermeloCollection, zermelo, from_zermelo_dict
+from .time_utils import get_date, get_year, datetime
+from .users import Leerling, Leerlingen, Personeel, Medewerker
+from .leerjaren import Leerjaren, Leerjaar
+from .groepen import Groep, Groepen
+from .lesgroepen import Lesgroepen, Lesgroep
+from .vakken import Vakken, Vak
+from dataclasses import dataclass, InitVar, field
+
+# branch is roughly translated to 'afdeling' in Dutch
+# for readability kept as branch, might be changed in the future
+
+logger = makeLogger("BRANCH")
+
+
+@dataclass
+class SchoolInSchoolYear:
+    id: int
+    # school: int
+    # year: int
+    # archived: bool
+    # name: str
+    # projectName: str
+    # schoolName: str
+    # schoolHrmsCode: str
+
+
+@dataclass
+class Branch:
+    id: int
+    schoolInSchoolYear: int
+    branch: str
+    name: str
+    schoolYear: int
+    date: datetime = datetime.now()
+    leerlingen: list[Leerling] = field(default_factory=list)
+    personeel: list[Medewerker] = field(default_factory=list)
+    leerjaren: list[Leerjaar] = field(default_factory=list)
+    vakken: Vakken = field(default_factory=list)
+    groepen: Groepen = field(default_factory=list)
+
+    def __post_init__(self):
+        logger.info(f"*** loading branch: {self.name} ***")
+        self.leerlingen = Leerlingen(self.schoolInSchoolYear)
+        self.personeel = Personeel(self.schoolInSchoolYear)
+        self.leerjaren = Leerjaren(self.schoolInSchoolYear)
+        self.groepen = Groepen(self.schoolInSchoolYear)
+        self.vakken = Vakken(self.schoolInSchoolYear)
+
+    def find_lesgroepen(self) -> Lesgroepen | bool:
+        if self.leerlingen and self.personeel:
+            return Lesgroepen(
+                self.leerjaren,
+                self.vakken,
+                self.groepen,
+                self.leerlingen,
+                self.personeel,
+            )
+        return False
+
+
+@dataclass
+class Branches(ZermeloCollection, list[Branch]):
+    datestring: InitVar = ""
+
+    def __post_init__(self, datestring):
+        logger.debug("init branches")
+        date = get_date(datestring)
+        year = get_year(datestring)
+        logger.debug(year)
+        query = f"schoolsinschoolyears/?year={year}&archived=False"
+        data = zermelo.load_query(query)
+        for schoolrow in data:
+            school = from_zermelo_dict(SchoolInSchoolYear, schoolrow)
+            query = f"branchesofschools/?schoolInSchoolYear={school.id}"
+            self.load_collection(query, Branch)
+        for branch in self:
+            branch.date = date
+
+    def __str__(self):
+        return "Branches(" + ", ".join([br.name for br in self]) + ")"
+
+    def get(self, name: str) -> Branch:
+        logger.info(f"loading branch: {name} ")
+        for branch in self:
+            if (
+                name.lower() in branch.branch.lower()
+                or branch.branch.lower() in name.lower()
+            ):
+                return branch
+        else:
+            logger.error(f"NO Branch found for {name}")

zermelo_api/src/config.py

@@ -0,0 +1,52 @@
+from os import path, mkdir
+from shutil import copyfile
+import json
+
+
+class getConfig:
+    def __init__(self, file):
+        HOMEDIR = getConfigDir()
+        filename = file + ".json"
+        backupname = file + ".bak"
+        if not HOMEDIR:
+            raise Exception("Kan configuratie directory niet aanmaken")
+        self.filepath = path.join(HOMEDIR, filename)
+        self.backup = path.join(HOMEDIR, backupname)
+
+    def __repr__(self):
+        return f'ConfigFile(path="{self.filepath}")'
+
+    def save(self, data):
+        try:
+            copyfile(self.filepath, self.backup)
+        except Exception:
+            print("warning - geen datafile")
+        try:
+            with open(self.filepath, "w") as file:
+                json.dump(data, file, indent=2)
+        except Exception:
+            return False
+        return True
+
+    def load(self):
+        data = {}
+        for file in [self.filepath, self.backup]:
+            try:
+                if path.isfile(file):
+                    with open(file, "r") as json_file:
+                        data = json.load(json_file)
+            except Exception:
+                continue
+            return data
+
+    def get(self, key: str = None):
+        data = self.load()
+        if not key:
+            return data
+        return data[key] if key in data else {}
+
+
+def getConfigDir():
+    abspath = path.abspath(__file__)
+    dname = path.dirname(abspath)
+    return dname

zermelo_api/src/credentials.py

@@ -0,0 +1,26 @@
+from .config import getConfig
+from .logger import makeLogger, INFO, DEBUG
+
+logger = makeLogger("creds", INFO)
+
+
+class Credentials:
+    def __init__(self):
+        self.file = getConfig("creds")
+        self.token = ""
+        self.load()
+
+    def load(self):
+        self.token = ""
+        try:
+            data = self.file.load()
+            self.token = data["token"]
+        except Exception as e:
+            logger.trace()
+        finally:
+            logger.debug(f"token: {self.token}")
+            return True if self.token else False
+
+    def settoken(self, token):
+        self.file.save({"token": token})
+        self.token = token

zermelo_api/src/groepen.py

@@ -0,0 +1,35 @@
+from .zermelo_api import ZermeloCollection, zermelo
+from .logger import makeLogger
+from dataclasses import dataclass, InitVar
+
+logger = makeLogger("GROEPEN")
+
+
+@dataclass
+class Groep:
+    id: int
+    isMainGroup: bool
+    isMentorGroup: bool
+    departmentOfBranch: int
+    name: str
+    extendedName: str
+
+
+@dataclass
+class Groepen(ZermeloCollection, list[Groep]):
+    schoolinschoolyear: InitVar
+
+    def __post_init__(self, schoolinschoolyear: int):
+        query = f"groupindepartments?schoolInSchoolYear={schoolinschoolyear}"
+        self.load_collection(query, Groep)
+
+    def get_department_groups(
+        self, departmentOfBranch: int, maingroup: bool = False
+    ) -> list[Groep]:
+        # returns all groups (if it is/isnt stamklas (maingroup))
+        return [
+            groep
+            for groep in self
+            if groep.departmentOfBranch == departmentOfBranch
+            and groep.isMainGroup == maingroup
+        ]

zermelo_api/src/leerjaren.py

@@ -0,0 +1,48 @@
+from .zermelo_api import ZermeloCollection
+from .logger import makeLogger
+from dataclasses import dataclass, InitVar
+
+# Leerjaar is a rough dutch translation of department in Zermelo
+
+logger = makeLogger("Leerjaren")
+
+
+def getLeerjaarNaam(string):
+    names = {"LG1": "klas 1", "LG2": "klas 2", "LG3": "klas 3"}
+    for name, result in names.items():
+        if name in string:
+            return result
+    else:
+        return string
+
+
+@dataclass
+class Leerjaar:
+    id: int
+    code: str
+    yearOfEducation: int
+    branchOfSchool: int
+    teacherTeams: list[int]
+    mainGroupAuthority: str
+    educationType: str
+    weekTimeTable: int
+    teachingLevel: str
+    educations: list[int]
+    schoolInSchoolYear: int
+    branchOfSchoolCode: str
+    schoolInSchoolYearName: str
+    profiles: list[int]
+    schoolInSchoolYearId: int
+    name: str = ""
+
+    def __post_init__(self):
+        self.name = getLeerjaarNaam(self.code.upper())
+
+
+@dataclass
+class Leerjaren(ZermeloCollection, list[Leerjaar]):
+    schoolinschoolyear: InitVar
+
+    def __post_init__(self, schoolinschoolyear: int):
+        query = f"departmentsofbranches?schoolInSchoolYear={schoolinschoolyear}"
+        self.load_collection(query, Leerjaar)

zermelo_api/src/lesgroepen.py

@@ -0,0 +1,238 @@
+from dataclasses import dataclass, field, InitVar
+from .vakken import Vakken, Vak
+from .groepen import Groepen, Groep
+from .users import Leerlingen, Leerling, Personeel, Medewerker
+from .leerjaren import Leerjaren, Leerjaar
+from .time_utils import get_date, delta_week
+from .logger import makeLogger, DEBUG
+from .zermelo_api import zermelo, from_zermelo_dict
+
+# from typing import Tuple
+
+logger = makeLogger("LESGROEP")
+
+
+def createLesgroepNaam(vak: Vak, groep: Groep) -> str:
+    leerjaar, groepnaam = groep.extendedName.split(".")
+    jaarnaam = leerjaar[2:].upper()
+    if vak.subjectCode in groepnaam:
+        return f"{jaarnaam}.{groepnaam}"
+    else:
+        return f"{jaarnaam}.{vak.subjectCode}{groepnaam[-1]}"
+
+
+def find_groepen(vak: Vak, groepen: Groepen) -> list[Groep]:
+    result = []
+    logger.debug(f"finding groep for vak: {vak.subjectCode}")
+    for groep in groepen.get_department_groups(vak.departmentOfBranch):
+        if groep in result:
+            continue
+        if vak.qualifiedCode and vak.qualifiedCode in groep.extendedName:
+            logger.debug(
+                f"found {groep.name} with {vak.qualifiedCode} in {groep.extendedName}"
+            )
+            result.append(groep)
+    return result
+
+
+def clean_docs(docs: list[str]) -> list[str]:
+    checklist = list(set(docs))
+    if "lgverv" in checklist:
+        checklist.remove("lgverv")
+    max = 0
+    if len(checklist) > 1:
+        logger.warning(f"multiple docs: {checklist}")
+        for doc in checklist:
+            doc_count = docs.count(doc)
+            if doc_count > max:
+                result = doc
+                max = doc_count
+        logger.warning(f"result: {result} ({max})")
+        return [result]
+    return checklist
+
+
+@dataclass
+class Les:
+    id: int
+    appointmentInstance: int
+    teachers: list[str]
+    students: list[str]
+    subjects: list[str]
+    groups: list[str]
+    groupsInDepartments: list[int]
+    choosableInDepartmentCodes: list[str]
+    valid: bool
+    cancelled: bool
+
+    def filter(self, name: str) -> bool:
+        if self.cancelled:
+            return False
+        if not self.valid:
+            return False
+        if len(self.students) > 40:
+            logger.debug("groep te groot")
+            return False
+        if not any([name.split(".")[-1] in group for group in self.groups]):
+            logger.debug(f"{name} not in {self}")
+            return False
+        return True
+
+
+def get_vak_data(
+    id: int, code: str, groupName: str, start, eind
+) -> tuple[list[int], list[str], list[str]]:
+    query = f"appointments/?containsStudentsFromGroupInDepartment={id}&subjects={code}&type=lesson&start={start}&end={eind}&fields=appointmentInstance,id,teachers,students,subjects,groups,groupsInDepartments,choosableInDepartmentCodes,valid,cancelled"
+    vakdata = zermelo.load_query(query)
+    grp_bck = []
+    ll_bck = []
+    doc_bck = []
+    leerlingen = []
+    docenten = []
+    grp_namen = []
+    lessen = [Les(**row) for row in reversed(vakdata) if row]
+    for les in [les for les in lessen if les.filter(groupName)]:
+        if len(les.groups) > 1:
+            if not grp_namen and not grp_bck or len(les.groups) < len(grp_bck):
+                logger.debug("meerdere groepen")
+                grp_bck = les.choosableInDepartmentCodes
+                ll_bck = list(set([llnr for llnr in les.students]))
+                doc_bck = list(set([doc for doc in les.teachers]))
+            continue
+        if les.students and les.teachers:
+            [leerlingen.append(llnr) for llnr in les.students if llnr not in leerlingen]
+            [docenten.append(doc) for doc in les.teachers]
+            [
+                grp_namen.append(grp)
+                for grp in les.choosableInDepartmentCodes
+                if grp not in grp_namen
+            ]
+    if not grp_namen and grp_bck:
+        logger.debug(f"result groepen: {grp_bck}")
+        grp_namen = grp_bck
+    if not docenten and doc_bck:
+        logger.debug(f"result docenten: {doc_bck}")
+        docenten = doc_bck
+    if not leerlingen and ll_bck:
+        logger.debug(f"result leerlingen: {ll_bck}")
+        leerlingen = ll_bck
+    docenten = clean_docs(docenten)
+    leerlingen = [int(llnr) for llnr in leerlingen]
+    return (leerlingen, docenten, grp_namen)
+
+
+def find_deelnemers(
+    vak: Vak, groep: Groep
+) -> tuple[list[int], list[str], list[str]] | bool:
+    date = get_date()
+    try:
+        logger.debug(groep)
+        for x in [0, -1, -2, 1, 2, 3]:
+            dweek = x * 4
+            starttijd = int(delta_week(date, dweek).timestamp())
+            eindtijd = int(delta_week(date, dweek + 4).timestamp())
+            data = get_vak_data(
+                groep.id, vak.subjectCode, groep.extendedName, starttijd, eindtijd
+            )
+            leerlingen, docenten, groep_namen = data
+            if len(leerlingen) and len(docenten):
+                logger.debug(f"found for {groep}")
+                namen = [
+                    groepnaam
+                    for groepnaam in groep_namen
+                    if vak.departmentOfBranchCode in groepnaam
+                ]
+                return (leerlingen, docenten, namen)
+        if not len(leerlingen) or not len(docenten):
+            logger.debug(f"geen deelnemers gevonden voor {groep}\n {vak}")
+            return False
+    except Exception:
+        logger.trace()
+        return False
+
+
+def get_info(
+    llnrs: list[int],
+    doc_codes: list[str],
+    names: list[str],
+    ll: Leerlingen,
+    docs: Personeel,
+) -> tuple[list[Leerling], list[Medewerker], list[str]]:
+    leerlingen = [ll.get(llnr) for llnr in llnrs]
+    docenten = [docs.get(code) for code in doc_codes]
+    return (leerlingen, docenten, names)
+
+
+@dataclass
+class Lesgroep:
+    vak: Vak
+    groep: Groep
+    leerjaar: Leerjaar
+    leerlingen: list[Leerling] = field(default_factory=list)
+    docenten: list[Medewerker] = field(default_factory=list)
+    namen: list[str] = field(default_factory=list)
+    naam: str = ""
+
+    def __post_init__(self):
+        self.naam = createLesgroepNaam(self.vak, self.groep)
+        for leerling in self.leerlingen:
+            leerling.leerjaren.add(self.leerjaar.id)
+
+
+@dataclass
+class Lesgroepen(list[Lesgroep]):
+    leerjaren: InitVar
+    vakken: InitVar
+    groepen: InitVar
+    leerlingen: InitVar
+    personeel: InitVar
+
+    def __post_init__(
+        self,
+        leerjaren: Leerjaren,
+        vakken: Vakken,
+        groepen: Groepen,
+        leerlingen: Leerlingen,
+        personeel: Personeel,
+    ):
+        for leerjaar in leerjaren:
+            for vak in vakken.get_leerjaar_vakken(leerjaar.id):
+                if vak.subjectType in ["education", "profile"] or vak.scheduleCode in [
+                    "lo",
+                    "sport",
+                ]:
+                    # skip educatio / profile / lo
+                    continue
+                logger.debug(vak)
+                found = False
+                for groep in find_groepen(vak, groepen):
+                    groepinfo = find_deelnemers(vak, groep)
+                    if groepinfo:
+                        data = get_info(*groepinfo, leerlingen, personeel)
+                        self.append(Lesgroep(vak, groep, leerjaar, *data))
+                        found = True
+                if found:
+                    continue
+                logger.debug(f"trying maingroups for {vak.subjectName}")
+                for groep in groepen.get_department_groups(
+                    vak.departmentOfBranch, True
+                ):
+                    logger.debug(f"trying: {groep}")
+                    groepinfo = find_deelnemers(vak, groep)
+                    if groepinfo:
+                        data = get_info(*groepinfo, leerlingen, personeel)
+                        self.append(Lesgroep(vak, groep, leerjaar, *data))
+                        found = True
+                if not found:
+                    logger.warning(f"geen groepen gevonden voor {vak}")
+        self.clean_leerlingen()
+        logger.info(f"found {len(self)} lesgroepen")
+
+    def clean_leerlingen(self):
+        for lesgroep in self:
+            for leerling in lesgroep.leerlingen.copy():
+                if leerling.leerjaren.get_id() != lesgroep.leerjaar.id:
+                    logger.warning(
+                        f"removing leerling ({leerling.fullName}) from {lesgroep.naam}"
+                    )
+                    lesgroep.leerlingen.remove(leerling)

zermelo_api/src/logger.py

@@ -0,0 +1,47 @@
+import logging
+import logging.handlers
+from logging import Logger
+from logging import DEBUG, INFO, WARNING, ERROR
+from os import path, mkdir
+from traceback import format_exc
+
+FOLDER = "log"
+FILE = "info"
+
+
+class MyLogger(Logger):
+    def trace(self):
+        self.error(format_exc())
+
+    def header(self, text: str):
+        self.info(f" ###### {text.upper()} ######")
+
+    def write(self, text: str):
+        text.replace("\n", "")
+        self.debug(text)
+
+
+def makeLogger(name: str = None, LOG_LEVEL: int = INFO, filename=FILE) -> MyLogger:
+    logger = logging.getLogger(name)
+    logger.setLevel(LOG_LEVEL)
+    # if not path.isdir(FOLDER):
+    #     mkdir(FOLDER)
+    # filename = path.join(FOLDER, f"{filename}.log")
+
+    # create console handler and set level to debug
+    # handler = logging.handlers.TimedRotatingFileHandler(
+    #     filename, when="W4", backupCount=3, encoding="utf-8"
+    # )
+    handler = logging.StreamHandler()
+    handler.setLevel(LOG_LEVEL)
+
+    formatter = logging.Formatter(
+        "%(asctime)s - %(levelname)s - %(name)s - %(message)s"
+    )
+    handler.setFormatter(formatter)
+
+    logger.addHandler(handler)
+
+    logger.__class__ = MyLogger
+
+    return logger

zermelo_api/src/time_utils.py

@@ -0,0 +1,18 @@
+from datetime import datetime, timedelta
+
+
+def get_date(datestring: str = "") -> datetime:
+    try:
+        date = datetime.strptime(datestring, "%Y-%m-%d")
+    except:
+        date = datetime.today()
+    finally:
+        return date
+
+
+def delta_week(date: datetime, delta: int = 0) -> datetime:
+    return date + timedelta(weeks=delta)
+
+
+def get_year(datestring: str = "") -> int:
+    return delta_week(get_date(datestring), -33).strftime("%Y")

zermelo_api/src/users.py

@@ -0,0 +1,139 @@
+from .zermelo_api import ZermeloCollection, zermelo, from_zermelo_dict
+from .logger import makeLogger
+from dataclasses import dataclass, InitVar, field
+
+logger = makeLogger("USERS")
+
+
+@dataclass
+class User:
+    code: str
+    roles: list[str]
+    firstName: str
+    prefix: str
+    lastName: str
+    schoolInSchoolYears: list[int]
+    isApplicationManager: bool
+    archived: bool
+    isStudent: bool
+    isEmployee: bool
+    isFamilyMember: bool
+    hasPassword: bool
+    isSchoolScheduler: bool
+    isSchoolLeader: bool
+    isStudentAdministrator: bool
+    isTeamLeader: bool
+    isSectionLeader: bool
+    isMentor: bool
+    isParentTeacherNightScheduler: bool
+    isDean: bool
+    fullName: str = ""
+
+    def __post_init__(self):
+        self.fullName = self.generatename()
+
+    def generatename(self) -> str:
+        if self.prefix:
+            fullname = " ".join(
+                [self.firstName, self.prefix, self.lastName.split(",")[0]]
+            )
+        elif self.firstName is not None and self.lastName is not None:
+            fullname = " ".join([self.firstName, self.lastName])
+        elif self.lastName is not None:
+            fullname = self.lastName
+        else:
+            fullname = "unknown"
+        return fullname
+
+
+class Users(list[User]):
+    def print_list(self):
+        return (
+            f" = [" + ", ".join([str(user) for user in self]) + "]" if len(self) else ""
+        )
+
+
+@dataclass
+class LeerjaarCounter:
+    id: int
+    count: int = 0
+
+
+class LeerjaarCounters(list[LeerjaarCounter]):
+    def get(self, id) -> LeerjaarCounter:
+        for ljcounter in self:
+            if ljcounter.id == id:
+                return ljcounter
+        self.append(LeerjaarCounter(id))
+        return self[-1]
+
+    def add(self, leerjaar_id: int):
+        counter = self.get(leerjaar_id)
+        counter.count += 1
+
+    def get_id(self) -> int:
+        if len(self):
+            self.sort(key=lambda x: x.count, reverse=True)
+            return self[0].id
+        return 0
+
+
+@dataclass
+class Leerling(User):
+    volgnr: int = 0
+    leerjaren: LeerjaarCounters = field(default_factory=LeerjaarCounters)
+
+
+@dataclass
+class Leerlingen(ZermeloCollection, Users, list[Leerling]):
+    schoolinschoolyear: InitVar
+
+    def __init__(self, schoolinschoolyear: int):
+        query = f"users?schoolInSchoolYear={schoolinschoolyear}&isStudent=true"
+        data = zermelo.load_query(query)
+        if data:
+            self.load_leerlingen(data)
+
+    def load_leerlingen(self, data: list[dict]):
+        logger.info("loading Leerlingen")
+        data.sort(key=lambda x: (x["lastName"], x["firstName"]))
+        for idx, row in enumerate(data):
+            self.append(from_zermelo_dict(Leerling, row, volgnr=idx + 1))
+        logger.info(f"found: {len(self)} leerlingen")
+
+    def __repr__(self):
+        return f"{self}{self.print_list()}"
+
+    def __str__(self):
+        return f"Leerlingen({len(self)})"
+
+    def get(self, llnr) -> Leerling:
+        for user in self:
+            if user.code == str(llnr):
+                return user
+
+
+@dataclass
+class Medewerker(User):
+    def __repr__(self):
+        return self.fullName + f"({self.code})"
+
+
+@dataclass
+class Personeel(ZermeloCollection, Users, list[Medewerker]):
+    schoolinschoolyear: InitVar
+
+    def __init__(self, schoolinschoolyear: int):
+        query = f"users?schoolInSchoolYear={schoolinschoolyear}&isEmployee=true"
+        self.load_collection(query, Medewerker)
+
+    def __repr__(self):
+        return f"{self}{self.print_list()}"
+
+    def __str__(self):
+        return f"Personeel({len(self)})"
+
+    def get(self, code: str):
+        for user in self:
+            if user.code == code:
+                return user

zermelo_api/src/vakken.py

@@ -0,0 +1,53 @@
+from .zermelo_api import ZermeloCollection, zermelo
+from .logger import makeLogger, DEBUG
+from .groepen import Groepen, Groep
+from dataclasses import dataclass, InitVar, field
+
+logger = makeLogger("VAKKEN")
+
+
+@dataclass
+class Vak:
+    id: int
+    subject: int
+    departmentOfBranch: int
+    studentCanEdit: bool
+    sectionOfBranch: int
+    courseType: str
+    lessonHoursInClassPeriods: list[dict]
+    excludedSegments: list[int]
+    referenceWeek: dict  # (year:int, weekNumber: int, schoolYear: int)
+    isExam: bool
+    scheduleCode: str
+    subjectType: str
+    subjectCode: str
+    departmentOfBranchCode: str
+    iltCode: int
+    qualifiedCode: str
+    subjectScheduleCode: str
+    subjectName: str
+    sectionOfBranchAbbreviation: str
+
+    def getName(self) -> str:
+        if "/" in self.subjectName:
+            logger.debug(f"old name: {self.subjectName}")
+            parts = self.subjectName.split("/")
+            frontpart = parts[0]
+            nameparts = frontpart.split(" ")
+            nameparts.pop(-1)
+            name = " ".join(nameparts)
+            logger.debug(f"new name: {name}")
+            return name.strip()
+        return self.subjectName.strip()
+
+
+@dataclass
+class Vakken(ZermeloCollection, list[Vak]):
+    schoolinschoolyear: InitVar
+
+    def __post_init__(self, schoolinschoolyear: int):
+        query = f"choosableindepartments?schoolInSchoolYear={schoolinschoolyear}"
+        self.load_collection(query, Vak)
+
+    def get_leerjaar_vakken(self, leerjaar_id: int) -> list[Vak]:
+        return [vak for vak in self if vak.departmentOfBranch == leerjaar_id]

zermelo_api/src/zermelo_api.py

@@ -0,0 +1,134 @@
+from .credentials import Credentials
+from .logger import makeLogger, DEBUG, INFO
+import json
+import requests
+import inspect
+
+logger = makeLogger("ZermeloAPI")
+
+ZERMELO_NAME = "carmelhengelo"
+
+
+class ZermeloAPI:
+    def __init__(self, school=ZERMELO_NAME):
+        self.credentials = Credentials()
+        self.zerurl = f"https://{school}.zportal.nl/api/v3/"
+
+    def login(self, code: str) -> bool:
+        token = self.get_access_token(code)
+        return self.add_token(token)
+
+    def get_access_token(self, code: str) -> str:
+        token = ""
+        url = self.zerurl + "oauth/token"
+        # headers = {"Content-Type": "application/json"}
+        zerrequest = requests.post(
+            url, data={"grant_type": "authorization_code", "code": code}
+        )
+        if zerrequest.status_code == 200:
+            data = json.loads(zerrequest.text)
+            if "access_token" in data:
+                token = data["access_token"]
+        return token
+
+    def add_token(self, token: str) -> bool:
+        if not token:
+            return False
+        self.credentials.settoken(token)
+        return self.checkCreds()
+
+    def checkCreds(self):
+        result = False
+        try:
+            self.getName()
+            result = True
+        except Exception as e:
+            logger.trace()
+            logger.error(e)
+        finally:
+            return result
+
+    def getName(self):
+        if not self.credentials.token:
+            raise Exception("No Token loaded!")
+        status, data = self.getData("users/~me", True)
+        if status != 200 or not len(data):
+            raise Exception("could not load user data with token")
+        logger.debug(f"get name: {data[0]}")
+        row = data[0]
+        if not row["prefix"]:
+            return " ".join([row["firstName"], row["lastName"]])
+        else:
+            return " ".join([row["firstName"], row["prefix"], row["lastName"]])
+
+    def getData(self, task, from_id=False) -> tuple[int, list[dict] | str]:
+        result = (500, [])
+        try:
+            request = (
+                self.zerurl + task + f"?access_token={self.credentials.token}"
+                if from_id
+                else self.zerurl + task + f"&access_token={self.credentials.token}"
+            )
+            logger.debug(request)
+            json_response = requests.get(request).json()
+            if json_response:
+                json_status = json_response["response"]["status"]
+                if json_status == 200:
+                    result = (200, json_response["response"]["data"])
+                    logger.debug("    **** JSON OK ****")
+                else:
+                    logger.debug(
+                        f"oeps, geen juiste response: {task} - {json_response['response']}"
+                    )
+                    result = (json_status, json_response["response"])
+            else:
+                logger.error("JSON - response is leeg")
+        except Exception as e:
+            logger.trace()
+        finally:
+            return result
+
+    def load_query(self, query: str) -> list[dict]:
+        try:
+            status, data = self.getData(query)
+            if status != 200:
+                raise Exception(f"Error loading data {status}")
+            if not data:
+                logger.debug("no data")
+        except Exception as e:
+            logger.debug(e)
+            data = []
+        return data
+
+
+zermelo = ZermeloAPI()
+
+if not zermelo.checkCreds():
+    with open("creds.ini") as f:
+        token = f.read()
+        zermelo.add_token(token)
+
+
+def from_zermelo_dict(cls, data: dict, *args, **kwargs):
+    [
+        logger.debug(f"{k} ({v}) not defined in {cls}")
+        for k, v in data.items()
+        if k not in inspect.signature(cls).parameters
+    ]
+    return cls(
+        *args,
+        **{k: v for k, v in data.items() if k in inspect.signature(cls).parameters},
+        **kwargs,
+    )
+
+
+class ZermeloCollection:
+    def load_collection(self: list, query: str, type: object) -> None:
+        data = zermelo.load_query(query)
+        for row in data:
+            self.append(from_zermelo_dict(type, row))
+
+    def test(self: list, query: str):
+        data = zermelo.load_query(query)
+        for row in data:
+            logger.info(f"test: {row}")

zermelo_api_vogk-0.2.16.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Klaas Vogel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zermelo_api_vogk-0.2.16.dist-info/METADATA

@@ -0,0 +1,112 @@
+Metadata-Version: 2.1
+Name: zermelo-api-vogk
+Version: 0.2.16
+Summary: A small module to create a Zermelo accesstoken and put some data from Zermelo in dataclasses
+Home-page: https://github.com/KlaasVogel/zermelo_api_vogk
+Author: Klaas Vogel
+Author-email: zermelo_api@klaasvogel.nl
+License: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Provides-Extra: dev
+
+## zermelo_api_vogk
+A small module to create a Zermelo accesstoken and put some data from Zermelo in dataclasses
+
+# V0.2.16
+ - found bug when running as daemon, probably: logger.
+ - try without output to file
+
+# V0.2.15
+ - disabled debug mode
+
+# V0.2.14
+ - debug on for bugfixing
+ - added extra debug log for filter in lesgroepen
+ - edit filter to find second part of groupname in les.groups
+
+# V0.2.13
+ - New bug: loading of stamgroepen as lesgroep is broken!
+ - need to update/edit filter in lesgroepen
+
+# V0.2.12
+ - removed debug for wisa and lesgroepen
+
+# V0.2.11
+ - added groep.extendentName to filter in lesgroep
+
+# V0.2.10
+ - trying to optimize lesgroepen
+ - added (temp) debug to lesgroepen
+ - log group
+
+# V0.2.9
+ - removed dependency of Groepen in Vakken (ot used)
+ - added getName to Vak (Vakken)
+ - start cleanup code
+
+# V0.2.8
+ - changed definition of Vakken and Groepen in Branch
+ - added Vakken & Vak to __init__.py 
+
+# V0.2.7
+ - added response as data in getData on wrong output
+ - refactoring of Appointments
+  * added function: get_department_updates [doesn't work atm :( ]
+
+# V0.2.6
+ - removed linebreaks from logger.write()
+
+# V0.2.5
+ - trying getting extra data for each appointment from user
+ - changed "with_id" in get_data to "from_id" and reversed functionality for better readability
+ - added classmethod to Appointment to get Appointment direct from id
+
+# V0.2.4
+ - added getting appointments
+
+# V0.2.3
+ - changed getting lesgroepen only as return so not part of branch anymore
+ - removed lastcheck from lesgroepen
+
+# V0.2.2
+ - bugfix lesgroepen
+ - added write to logger (debug)
+ - changed repr of Users
+
+# V0.2.1
+ - added datetime to each branch
+ - init of branches is now only datestring, year will be determined internally
+
+# V0.2.0
+ - changed decorator from_zermelo_dict to function
+
+# V0.1.3
+- added lesgroepen
+
+# V0.1.2
+- added Vakken
+
+# V0.1.1
+  - added groepen / groups
+  - First setup of vakken
+  - cleanup of code
+
+# V0.1.0: First Refactoring already:
+- deleted fields.py and moved usefull functions to zermelo_api
+- loading of data for (zermelo)list generalized in zermelo_api
+
+# V0.0.8:
+ - Added loading of Users (Leerlingen & Medewerkers)
+ - Added backtracker to MyLogger
+
+# V0.0.7:
+- Added Loading of Branches
+
+# V0.0.1 -> V0.0.5:
+- Experimenting with creating of own package and major structure of project

zermelo_api_vogk-0.2.16.dist-info/RECORD

@@ -0,0 +1,19 @@
+zermelo_api/__init__.py,sha256=judeG_xciHkFfKbkcM7S29LFaey0ljdwC7tnpo61TX0,401
+zermelo_api/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+zermelo_api/src/appointments.py,sha256=zHl41LsYWpJIaaHD1zTjgeKZXaNinTs9PxvKsbAzfLw,3019
+zermelo_api/src/branches.py,sha256=BlhsqaKPjE8hb5LPeZwiW3pXqS1AoZeNyaF2JVM5YCI,3023
+zermelo_api/src/config.py,sha256=_NMg7DVl0YvrsDblV8128TxNkWvHylIT8vFiqP6FwqI,1437
+zermelo_api/src/credentials.py,sha256=rfgOatC6yY4iq8Fc7DboJ2tnlcZjcxsbQEAVt_VpaC0,644
+zermelo_api/src/groepen.py,sha256=2HWDQxXgQaHYCJEFCmXJJH-qEB7mzeM3XLziGzKTT0M,941
+zermelo_api/src/leerjaren.py,sha256=2h8SZBOj9bm0w2mYL2T8rMbRfCoIkDib_6ElfkdaNR4,1216
+zermelo_api/src/lesgroepen.py,sha256=4o5C0q2ZfipkLnO9wpME-slYZFLTr5WEZvHNxFlRdl8,8417
+zermelo_api/src/logger.py,sha256=QEKNK6TrDDrLPtXnW1hPbJIIjhmKwps1eFCJaanJjHE,1202
+zermelo_api/src/time_utils.py,sha256=WAPhjZdaYFk3a5gtJGtH_Rmc2ckbQqpA_wMkzekdoOo,446
+zermelo_api/src/users.py,sha256=eus_ZwvEfmqWAG7cC7Si4-qUsUvBF-cLv_PkhIiIs-s,3696
+zermelo_api/src/vakken.py,sha256=ffYOjSi9f80ezCJeWjbQMc5fQAWAzTZTz6NayHuOdzc,1594
+zermelo_api/src/zermelo_api.py,sha256=QsDHBa0y3h8jdSHQCB7hgFWh_Z0IStIBBizwc6cqJHs,4256
+zermelo_api_vogk-0.2.16.dist-info/LICENSE,sha256=-g7wJAy8hK6L6CqC6eT8eGsW8t-6Ej8xK4pToiooumg,1068
+zermelo_api_vogk-0.2.16.dist-info/METADATA,sha256=Vh6gL8dGflyYBW2OSV5AR9XPzQfUT_1y5AAeywvlx2I,2922
+zermelo_api_vogk-0.2.16.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+zermelo_api_vogk-0.2.16.dist-info/top_level.txt,sha256=pDeE62UsvIU1PZdHVaksaQb3tkB5hvXla-bnHkLY-XA,12
+zermelo_api_vogk-0.2.16.dist-info/RECORD,,

zermelo_api_vogk-0.2.16.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

zermelo_api_vogk-0.2.16.dist-info/top_level.txt

@@ -0,0 +1 @@
+zermelo_api