Übungsaufgaben zum Schneiden von Klassen: Single Responsibility, Separation of Concerns, Information Hiding, Tell, don’t ask und Law of Demeter

// Bestellung.java
package de.csbrad.shop;

import java.util.List;

/** Eine Bestellung kennt ihre Positionen und berechnet ihre Beträge selbst (Tell, don't ask). */
public final class Bestellung {

    private static final String GUTSCHEINCODE_KURIER = "KURIER10";
    private static final int GUTSCHEIN_RABATT_PROZENT = 10;
    private static final int MEHRWERTSTEUER_PROZENT = 19;

    private final List<Position> positionen;
    private final String versandart;
    private final String gutscheincode;
    private final String kundenEmail;
    private final Versandkostenrechner versandkostenrechner;
    private String bestellnummer;

    public Bestellung(Bestellanfrage anfrage, Versandkostenrechner versandkostenrechner) {
        pruefePositionen(anfrage.positionen());
        this.positionen = List.copyOf(anfrage.positionen());
        this.versandart = anfrage.versandart();
        this.gutscheincode = anfrage.gutscheincode();
        this.kundenEmail = anfrage.kundenEmail();
        this.versandkostenrechner = versandkostenrechner;
        if (warenwert() == 0) {
            throw new IllegalArgumentException("Bestellung ohne Warenwert");
        }
    }

    private static void pruefePositionen(List<Position> positionen) {
        if (positionen.isEmpty()) {
            throw new IllegalArgumentException("Bestellung ohne Positionen");
        }
        for (Position position : positionen) {
            if (position.menge() <= 0) {
                throw new IllegalArgumentException("Menge muss positiv sein: " + position.artikelnr());
            }
        }
    }

    public int warenwert() {
        return positionen.stream().mapToInt(p -> p.nettopreisCent() * p.menge()).sum();
    }

    public int rabatt() {
        if (GUTSCHEINCODE_KURIER.equals(gutscheincode)) {
            return prozentKaufmaennischGerundet(warenwert(), GUTSCHEIN_RABATT_PROZENT);
        }
        return 0;
    }

    public int warenwertNachRabatt() {
        return warenwert() - rabatt();
    }

    public int versandkosten() {
        return versandkostenrechner.berechne(this);
    }

    public int mehrwertsteuer() {
        return prozentKaufmaennischGerundet(warenwertNachRabatt() + versandkosten(), MEHRWERTSTEUER_PROZENT);
    }

    public int gesamtbetrag() {
        return warenwertNachRabatt() + versandkosten() + mehrwertsteuer();
    }

    public int gesamtgewichtGramm() {
        return positionen.stream().mapToInt(p -> p.gewichtGramm() * p.menge()).sum();
    }

    public int anzahlRaeder() {
        return positionen.stream().filter(Position::istRad).mapToInt(Position::menge).sum();
    }

    public boolean enthaeltRad() {
        return positionen.stream().anyMatch(Position::istRad);
    }

    public String versandart() {
        return versandart;
    }

    public String kundenEmail() {
        return kundenEmail;
    }

    public String bestellnummer() {
        return bestellnummer;
    }

    void vergibNummer(String nummer) {
        if (bestellnummer != null) {
            throw new IllegalStateException("Bestellung hat schon eine Nummer: " + bestellnummer);
        }
        bestellnummer = nummer;
    }

    private static int prozentKaufmaennischGerundet(int betragCent, int prozent) {
        return (betragCent * prozent + 50) / 100;
    }
}

// Versandkostenrechner.java
package de.csbrad.shop;

import java.util.Set;

/** Kennt die Versandregeln der CSB-Rad GmbH. */
public class Versandkostenrechner {

    private static final Set<String> VERSANDARTEN = Set.of("PAKET", "SPEDITION", "ABHOLUNG");
    private static final int PAKETPAUSCHALE_CENT = 690;
    private static final int HOECHSTGEWICHT_PAKET_GRAMM = 31500;
    private static final int VERSANDKOSTENFREI_AB_CENT = 10000;
    private static final int SPEDITION_JE_RAD_CENT = 4900;

    public void pruefeVersandmoeglich(Bestellung bestellung) {
        if (!VERSANDARTEN.contains(bestellung.versandart())) {
            throw new IllegalArgumentException("Unbekannte Versandart: " + bestellung.versandart());
        }
        if (bestellung.versandart().equals("PAKET") && bestellung.enthaeltRad()) {
            throw new IllegalArgumentException("Räder können nicht als Paket versandt werden");
        }
    }

    public int berechne(Bestellung bestellung) {
        return switch (bestellung.versandart()) {
            case "PAKET" -> paketkosten(bestellung);
            // ohne Rad wird eine Speditionspauschale berechnet
            case "SPEDITION" -> Math.max(1, bestellung.anzahlRaeder()) * SPEDITION_JE_RAD_CENT;
            default -> 0;
        };
    }

    private int paketkosten(Bestellung bestellung) {
        if (bestellung.warenwertNachRabatt() >= VERSANDKOSTENFREI_AB_CENT) {
            return 0;
        }
        int anzahlPakete = Math.max(1, (bestellung.gesamtgewichtGramm() + HOECHSTGEWICHT_PAKET_GRAMM - 1) / HOECHSTGEWICHT_PAKET_GRAMM);
        return anzahlPakete * PAKETPAUSCHALE_CENT;
    }
}

// Mailversand.java
package de.csbrad.shop;

import java.util.ArrayList;
import java.util.List;

/** Verschickt Bestätigungsmails; hier nur in einen Postausgang (Liste). */
public class Mailversand {

    private final List<String> postausgang = new ArrayList<>();

    public void sendeBestaetigung(Bestellung bestellung) {
        postausgang.add("An: " + bestellung.kundenEmail() + "\nBestellung " + bestellung.bestellnummer()
                + "\nGesamtbetrag: " + alsEuroText(bestellung.gesamtbetrag()) + "\n" + versandzeile(bestellung.versandart()));
    }

    public List<String> postausgang() {
        return List.copyOf(postausgang);
    }

    private static String versandzeile(String versandart) {
        return switch (versandart) {
            case "PAKET" -> "Versand: Paket";
            case "SPEDITION" -> "Versand: Spedition";
            default -> "Abholung in der Werkstatt Bielefeld-Sennestadt";
        };
    }

    private static String alsEuroText(int betragCent) {
        return (betragCent / 100) + "," + String.format("%02d", betragCent % 100) + " EUR";
    }
}

// BestellRepository.java
package de.csbrad.shop;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/** Speichert Bestellungen (hier im Arbeitsspeicher) und vergibt fortlaufende Bestellnummern. */
public class BestellRepository {

    private static final int ERSTE_BESTELLNUMMER = 1001;

    private final List<Bestellung> bestellungen = new ArrayList<>();
    private int naechsteNummer = ERSTE_BESTELLNUMMER;

    public void speichere(Bestellung bestellung) {
        bestellung.vergibNummer("CSB-" + naechsteNummer);
        naechsteNummer = naechsteNummer + 1;
        bestellungen.add(bestellung);
    }

    public Optional<Bestellung> findeNachNummer(String bestellnummer) {
        return bestellungen.stream().filter(b -> b.bestellnummer().equals(bestellnummer)).findFirst();
    }

    public List<Bestellung> alle() {
        return List.copyOf(bestellungen);
    }
}

// Bestellabschluss.java
package de.csbrad.shop;

/** Ablauf des Bestellabschlusses: prüfen, speichern, bestätigen. */
public class Bestellabschluss {

    private final Versandkostenrechner versandkostenrechner = new Versandkostenrechner();
    private final Mailversand mailversand = new Mailversand();
    private final BestellRepository repository = new BestellRepository();

    public Bestellung abschliessen(Bestellanfrage anfrage) {
        Bestellung bestellung = new Bestellung(anfrage, versandkostenrechner);
        versandkostenrechner.pruefeVersandmoeglich(bestellung);
        repository.speichere(bestellung);
        mailversand.sendeBestaetigung(bestellung);
        return bestellung;
    }

    public Mailversand mailversand() {
        return mailversand;
    }

    public BestellRepository repository() {
        return repository;
    }
}

# bestellung.py
from __future__ import annotations

from typing import TYPE_CHECKING

from csbrad.bestellanfrage import Bestellanfrage
from csbrad.position import Position

if TYPE_CHECKING:
    from csbrad.versandkostenrechner import Versandkostenrechner

GUTSCHEINCODE_KURIER = "KURIER10"
GUTSCHEIN_RABATT_PROZENT = 10
MEHRWERTSTEUER_PROZENT = 19


class Bestellung:
    """Eine Bestellung kennt ihre Positionen und berechnet ihre Beträge selbst (Tell, don't ask)."""

    def __init__(self, anfrage: Bestellanfrage, versandkostenrechner: Versandkostenrechner) -> None:
        _pruefe_positionen(anfrage.positionen)
        self._positionen = tuple(anfrage.positionen)
        self._versandart = anfrage.versandart
        self._gutscheincode = anfrage.gutscheincode
        self._kunden_email = anfrage.kunden_email
        self._versandkostenrechner = versandkostenrechner
        self._bestellnummer: str | None = None
        if self.warenwert() == 0:
            raise ValueError("Bestellung ohne Warenwert")

    def warenwert(self) -> int:
        return sum(p.nettopreis_cent * p.menge for p in self._positionen)

    def rabatt(self) -> int:
        if self._gutscheincode == GUTSCHEINCODE_KURIER:
            return _prozent_kaufmaennisch_gerundet(self.warenwert(), GUTSCHEIN_RABATT_PROZENT)
        return 0

    def warenwert_nach_rabatt(self) -> int:
        return self.warenwert() - self.rabatt()

    def versandkosten(self) -> int:
        return self._versandkostenrechner.berechne(self)

    def mehrwertsteuer(self) -> int:
        return _prozent_kaufmaennisch_gerundet(self.warenwert_nach_rabatt() + self.versandkosten(), MEHRWERTSTEUER_PROZENT)

    def gesamtbetrag(self) -> int:
        return self.warenwert_nach_rabatt() + self.versandkosten() + self.mehrwertsteuer()

    def gesamtgewicht_gramm(self) -> int:
        return sum(p.gewicht_gramm * p.menge for p in self._positionen)

    def anzahl_raeder(self) -> int:
        return sum(p.menge for p in self._positionen if p.ist_rad)

    def enthaelt_rad(self) -> bool:
        return any(p.ist_rad for p in self._positionen)

    @property
    def versandart(self) -> str:
        return self._versandart

    @property
    def kunden_email(self) -> str:
        return self._kunden_email

    @property
    def bestellnummer(self) -> str | None:
        return self._bestellnummer

    def vergib_nummer(self, nummer: str) -> None:
        if self._bestellnummer is not None:
            raise RuntimeError(f"Bestellung hat schon eine Nummer: {self._bestellnummer}")
        self._bestellnummer = nummer


def _pruefe_positionen(positionen: list[Position]) -> None:
    if not positionen:
        raise ValueError("Bestellung ohne Positionen")
    for position in positionen:
        if position.menge <= 0:
            raise ValueError(f"Menge muss positiv sein: {position.artikelnr}")


def _prozent_kaufmaennisch_gerundet(betrag_cent: int, prozent: int) -> int:
    return (betrag_cent * prozent + 50) // 100

# versandkostenrechner.py
from __future__ import annotations

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from csbrad.bestellung import Bestellung

VERSANDARTEN = {"PAKET", "SPEDITION", "ABHOLUNG"}
PAKETPAUSCHALE_CENT = 690
HOECHSTGEWICHT_PAKET_GRAMM = 31500
VERSANDKOSTENFREI_AB_CENT = 10000
SPEDITION_JE_RAD_CENT = 4900


class Versandkostenrechner:
    """Kennt die Versandregeln der CSB-Rad GmbH."""

    def pruefe_versand_moeglich(self, bestellung: Bestellung) -> None:
        if bestellung.versandart not in VERSANDARTEN:
            raise ValueError(f"Unbekannte Versandart: {bestellung.versandart}")
        if bestellung.versandart == "PAKET" and bestellung.enthaelt_rad():
            raise ValueError("Räder können nicht als Paket versandt werden")

    def berechne(self, bestellung: Bestellung) -> int:
        match bestellung.versandart:
            case "PAKET":
                return self._paketkosten(bestellung)
            case "SPEDITION":
                # ohne Rad wird eine Speditionspauschale berechnet
                return max(1, bestellung.anzahl_raeder()) * SPEDITION_JE_RAD_CENT
            case _:
                return 0

    def _paketkosten(self, bestellung: Bestellung) -> int:
        if bestellung.warenwert_nach_rabatt() >= VERSANDKOSTENFREI_AB_CENT:
            return 0
        anzahl_pakete = max(1, (bestellung.gesamtgewicht_gramm() + HOECHSTGEWICHT_PAKET_GRAMM - 1) // HOECHSTGEWICHT_PAKET_GRAMM)
        return anzahl_pakete * PAKETPAUSCHALE_CENT

# mailversand.py
from csbrad.bestellung import Bestellung


class Mailversand:
    """Verschickt Bestätigungsmails; hier nur in einen Postausgang (Liste)."""

    def __init__(self) -> None:
        self._postausgang: list[str] = []

    def sende_bestaetigung(self, bestellung: Bestellung) -> None:
        self._postausgang.append(
            f"An: {bestellung.kunden_email}\nBestellung {bestellung.bestellnummer}\n"
            f"Gesamtbetrag: {_als_euro_text(bestellung.gesamtbetrag())}\n{_versandzeile(bestellung.versandart)}")

    def postausgang(self) -> list[str]:
        return list(self._postausgang)


def _versandzeile(versandart: str) -> str:
    match versandart:
        case "PAKET":
            return "Versand: Paket"
        case "SPEDITION":
            return "Versand: Spedition"
        case _:
            return "Abholung in der Werkstatt Bielefeld-Sennestadt"


def _als_euro_text(betrag_cent: int) -> str:
    return f"{betrag_cent // 100},{betrag_cent % 100:02d} EUR"

# bestell_repository.py
from csbrad.bestellung import Bestellung

ERSTE_BESTELLNUMMER = 1001


class BestellRepository:
    """Speichert Bestellungen (hier im Arbeitsspeicher) und vergibt fortlaufende Bestellnummern."""

    def __init__(self) -> None:
        self._bestellungen: list[Bestellung] = []
        self._naechste_nummer = ERSTE_BESTELLNUMMER

    def speichere(self, bestellung: Bestellung) -> None:
        bestellung.vergib_nummer(f"CSB-{self._naechste_nummer}")
        self._naechste_nummer = self._naechste_nummer + 1
        self._bestellungen.append(bestellung)

    def finde_nach_nummer(self, bestellnummer: str) -> Bestellung | None:
        return next((b for b in self._bestellungen if b.bestellnummer == bestellnummer), None)

    def alle(self) -> list[Bestellung]:
        return list(self._bestellungen)

# bestellabschluss.py
from csbrad.bestell_repository import BestellRepository
from csbrad.bestellanfrage import Bestellanfrage
from csbrad.bestellung import Bestellung
from csbrad.mailversand import Mailversand
from csbrad.versandkostenrechner import Versandkostenrechner


class Bestellabschluss:
    """Ablauf des Bestellabschlusses: prüfen, speichern, bestätigen."""

    def __init__(self) -> None:
        self._versandkostenrechner = Versandkostenrechner()
        self._mailversand = Mailversand()
        self._repository = BestellRepository()

    def abschliessen(self, anfrage: Bestellanfrage) -> Bestellung:
        bestellung = Bestellung(anfrage, self._versandkostenrechner)
        self._versandkostenrechner.pruefe_versand_moeglich(bestellung)
        self._repository.speichere(bestellung)
        self._mailversand.sende_bestaetigung(bestellung)
        return bestellung

    @property
    def mailversand(self) -> Mailversand:
        return self._mailversand

    @property
    def repository(self) -> BestellRepository:
        return self._repository

// Fahrer.java
package de.mitfahrlabor;

import java.time.LocalDate;

public class Fahrer {

    private static final int PROBEZEIT_JAHRE = 2;

    private final Person person;

    public Fahrer(Person person) {
        this.person = person;
    }

    public String name() {
        return person.name();
    }

    public boolean inProbezeit(LocalDate heute) {
        return person.fuehrerscheinSeit().plusYears(PROBEZEIT_JAHRE).isAfter(heute);
    }
}

// Mitfahrt.java
package de.mitfahrlabor;

public class Mitfahrt {

    private final Person mitfahrende;
    private boolean bestaetigt;

    public Mitfahrt(Person mitfahrende) {
        this.mitfahrende = mitfahrende;
    }

    public String name() {
        return mitfahrende.name();
    }

    public boolean istBestaetigt() {
        return bestaetigt;
    }

    void bestaetige() {
        bestaetigt = true;
    }
}

// Fahrtangebot.java
package de.mitfahrlabor;

import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;

public class Fahrtangebot {

    private static final int HOECHSTBEITRAG_CENT_JE_KM = 10;

    private final Fahrer fahrer;
    private final String haltepunkt;
    private final int plaetze;
    private final int entfernungKm;
    private final int centJeKm;
    private final List<Mitfahrt> mitfahrten = new ArrayList<>();

    public Fahrtangebot(Fahrer fahrer, String haltepunkt, int plaetze, int entfernungKm, int centJeKm) {
        this.fahrer = fahrer;
        this.haltepunkt = haltepunkt;
        this.plaetze = plaetze;
        this.entfernungKm = entfernungKm;
        this.centJeKm = centJeKm;
    }

    public String haltepunkt() {
        return haltepunkt;
    }

    public String fahrerName() {
        return fahrer.name();
    }

    public boolean fahrerInProbezeit(LocalDate heute) {
        return fahrer.inProbezeit(heute);
    }

    public int freiePlaetze() {
        return plaetze - (int) mitfahrten.stream().filter(Mitfahrt::istBestaetigt).count();
    }

    public void bestaetige(Mitfahrt mitfahrt) {
        if (freiePlaetze() <= 0) {
            throw new IllegalStateException("Kein Platz mehr frei");
        }
        mitfahrt.bestaetige();
        if (!mitfahrten.contains(mitfahrt)) {
            mitfahrten.add(mitfahrt);
        }
    }

    public int kostenbeitragCent() {
        return Math.min(centJeKm, HOECHSTBEITRAG_CENT_JE_KM) * entfernungKm;
    }
}

// Buchungsdienst.java
package de.mitfahrlabor;

import java.time.LocalDate;

public class Buchungsdienst {

    public String probezeitHinweis(Fahrtangebot fahrt, LocalDate heute) {
        if (fahrt.fahrerInProbezeit(heute)) {
            return "Hinweis für " + fahrt.fahrerName() + ": Du bist in der Probezeit und trägst Verantwortung für Deine Mitfahrenden.";
        }
        return "";
    }

    public void bestaetige(Fahrtangebot fahrt, Mitfahrt mitfahrt) {
        fahrt.bestaetige(mitfahrt);
    }

    public int kostenbeitragCent(Fahrtangebot fahrt) {
        return fahrt.kostenbeitragCent();
    }
}

from dataclasses import dataclass
from datetime import date

PROBEZEIT_JAHRE = 2
HOECHSTBEITRAG_CENT_JE_KM = 10


@dataclass(frozen=True)
class Person:
    """Reine Datenstruktur: Name, Alter, Führerschein seit (None = kein Führerschein)."""

    name: str
    alter: int
    fuehrerschein_seit: date | None


class Fahrer:

    def __init__(self, person: Person) -> None:
        self._person = person

    @property
    def name(self) -> str:
        return self._person.name

    def in_probezeit(self, heute: date) -> bool:
        seit = self._person.fuehrerschein_seit
        return seit is not None and seit.replace(year=seit.year + PROBEZEIT_JAHRE) > heute


class Mitfahrt:

    def __init__(self, mitfahrende: Person) -> None:
        self._mitfahrende = mitfahrende
        self._bestaetigt = False

    @property
    def name(self) -> str:
        return self._mitfahrende.name

    def ist_bestaetigt(self) -> bool:
        return self._bestaetigt

    def _bestaetige(self) -> None:
        self._bestaetigt = True


class Fahrtangebot:

    def __init__(self, fahrer: Fahrer, haltepunkt: str, plaetze: int, entfernung_km: int, cent_je_km: int) -> None:
        self._fahrer = fahrer
        self._haltepunkt = haltepunkt
        self._plaetze = plaetze
        self._entfernung_km = entfernung_km
        self._cent_je_km = cent_je_km
        self._mitfahrten: list[Mitfahrt] = []

    @property
    def haltepunkt(self) -> str:
        return self._haltepunkt

    @property
    def fahrer_name(self) -> str:
        return self._fahrer.name

    def fahrer_in_probezeit(self, heute: date) -> bool:
        return self._fahrer.in_probezeit(heute)

    def freie_plaetze(self) -> int:
        return self._plaetze - sum(1 for m in self._mitfahrten if m.ist_bestaetigt())

    def bestaetige(self, mitfahrt: Mitfahrt) -> None:
        if self.freie_plaetze() <= 0:
            raise RuntimeError("Kein Platz mehr frei")
        mitfahrt._bestaetige()  # Mitfahrt gehört zum selben Modul (Konvention)
        if mitfahrt not in self._mitfahrten:
            self._mitfahrten.append(mitfahrt)

    def kostenbeitrag_cent(self) -> int:
        return min(self._cent_je_km, HOECHSTBEITRAG_CENT_JE_KM) * self._entfernung_km


class Buchungsdienst:

    def probezeit_hinweis(self, fahrt: Fahrtangebot, heute: date) -> str:
        if fahrt.fahrer_in_probezeit(heute):
            return (f"Hinweis für {fahrt.fahrer_name}: Du bist in der Probezeit "
                    "und trägst Verantwortung für Deine Mitfahrenden.")
        return ""

    def bestaetige(self, fahrt: Fahrtangebot, mitfahrt: Mitfahrt) -> None:
        fahrt.bestaetige(mitfahrt)

    def kostenbeitrag_cent(self, fahrt: Fahrtangebot) -> int:
        return fahrt.kostenbeitrag_cent()

package de.mitfahrlabor;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.time.LocalDate;
import org.junit.jupiter.api.Test;

class FahrtangebotTest {

    static final LocalDate HEUTE = LocalDate.of(2026, 11, 9);
    static final Person BEN = new Person("Ben Richter", 18, LocalDate.of(2026, 1, 15));
    static final Person NIKLAS = new Person("Niklas Fischer", 24, LocalDate.of(2020, 5, 4));
    static final Person AYLIN = new Person("Aylin Kaya", 17, null);
    static final Person OKSANA = new Person("Oksana Melnyk", 23, null);

    @Test
    void benIstInDerProbezeit() {
        Fahrtangebot fahrt = new Fahrtangebot(new Fahrer(BEN), "Gütersloh ZOB", 3, 18, 8);
        assertTrue(fahrt.fahrerInProbezeit(HEUTE));
        assertTrue(new Buchungsdienst().probezeitHinweis(fahrt, HEUTE).startsWith("Hinweis für Ben Richter"));
    }

    @Test
    void niklasIstNichtInDerProbezeit() {
        Fahrtangebot fahrt = new Fahrtangebot(new Fahrer(NIKLAS), "Bad Salzuflen Bahnhof", 7, 15, 10);
        assertFalse(fahrt.fahrerInProbezeit(HEUTE));
        assertEquals("", new Buchungsdienst().probezeitHinweis(fahrt, HEUTE));
    }

    @Test
    void volleFahrtLehntAb() {
        Fahrtangebot fahrt = new Fahrtangebot(new Fahrer(BEN), "Gütersloh ZOB", 1, 18, 8);
        fahrt.bestaetige(new Mitfahrt(AYLIN));
        Mitfahrt oksana = new Mitfahrt(OKSANA);
        assertThrows(IllegalStateException.class, () -> fahrt.bestaetige(oksana));
        assertFalse(oksana.istBestaetigt());
        assertEquals(0, fahrt.freiePlaetze());
    }

    @Test
    void kostenbeitragHoechstensZehnCentJeKm() {
        assertEquals(144, new Fahrtangebot(new Fahrer(BEN), "Gütersloh ZOB", 3, 18, 8).kostenbeitragCent());
        assertEquals(150, new Fahrtangebot(new Fahrer(NIKLAS), "Bad Salzuflen Bahnhof", 7, 15, 12).kostenbeitragCent());
    }
}

from datetime import date

import pytest

from mitfahrlabor.fahrten import Buchungsdienst, Fahrer, Fahrtangebot, Mitfahrt, Person

HEUTE = date(2026, 11, 9)
BEN = Person("Ben Richter", 18, date(2026, 1, 15))
NIKLAS = Person("Niklas Fischer", 24, date(2020, 5, 4))
AYLIN = Person("Aylin Kaya", 17, None)
OKSANA = Person("Oksana Melnyk", 23, None)


def test_ben_ist_in_der_probezeit() -> None:
    fahrt = Fahrtangebot(Fahrer(BEN), "Gütersloh ZOB", 3, 18, 8)
    assert fahrt.fahrer_in_probezeit(HEUTE)
    assert Buchungsdienst().probezeit_hinweis(fahrt, HEUTE).startswith("Hinweis für Ben Richter")


def test_niklas_ist_nicht_in_der_probezeit() -> None:
    fahrt = Fahrtangebot(Fahrer(NIKLAS), "Bad Salzuflen Bahnhof", 7, 15, 10)
    assert not fahrt.fahrer_in_probezeit(HEUTE)
    assert Buchungsdienst().probezeit_hinweis(fahrt, HEUTE) == ""


def test_volle_fahrt_lehnt_ab() -> None:
    fahrt = Fahrtangebot(Fahrer(BEN), "Gütersloh ZOB", 1, 18, 8)
    fahrt.bestaetige(Mitfahrt(AYLIN))
    oksana = Mitfahrt(OKSANA)
    with pytest.raises(RuntimeError):
        fahrt.bestaetige(oksana)
    assert not oksana.ist_bestaetigt()
    assert fahrt.freie_plaetze() == 0


def test_kostenbeitrag_hoechstens_zehn_cent_je_km() -> None:
    assert Fahrtangebot(Fahrer(BEN), "Gütersloh ZOB", 3, 18, 8).kostenbeitrag_cent() == 144
    assert Fahrtangebot(Fahrer(NIKLAS), "Bad Salzuflen Bahnhof", 7, 15, 12).kostenbeitrag_cent() == 150

// Angebotsdatensatz.java
package de.mitfahrlabor.monitor;

import java.time.LocalTime;

/** Ein gespeichertes Fahrtangebot, so wie es in der Datei steht. */
public record Angebotsdatensatz(String id, String fahrer, String haltepunkt, String richtung, LocalTime abfahrt, int freiePlaetze) {
}

// Monitoreintrag.java
package de.mitfahrlabor.monitor;

import java.time.LocalTime;

/** Was ein Flurmonitor zeigen darf: kein Name, keine ID. */
public record Monitoreintrag(String haltepunkt, String richtung, LocalTime abfahrt, int freiePlaetze) {
}

// AngebotsDatei.java
package de.mitfahrlabor.monitor;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;

/** Speicherung: kennt Dateiformat und Spaltenreihenfolge. */
public class AngebotsDatei {

    private final Path datei;

    public AngebotsDatei(Path datei) {
        this.datei = datei;
    }

    public List<Angebotsdatensatz> alle() throws IOException {
        List<Angebotsdatensatz> angebote = new ArrayList<>();
        for (String zeile : Files.readAllLines(datei, StandardCharsets.UTF_8)) {
            if (!zeile.isBlank() && !zeile.startsWith("#")) {
                angebote.add(alsDatensatz(zeile.split(";")));
            }
        }
        return angebote;
    }

    private static Angebotsdatensatz alsDatensatz(String[] f) {
        return new Angebotsdatensatz(f[0], f[1], f[2], f[3], LocalTime.parse(f[4]), Integer.parseInt(f[5]));
    }
}

// Monitorauswahl.java
package de.mitfahrlabor.monitor;

import java.time.LocalTime;
import java.util.List;

/** Fachlogik: welche Angebote ein Monitor zeigt, und zwar anonym. */
public class Monitorauswahl {

    public List<Monitoreintrag> offeneAngebote(List<Angebotsdatensatz> angebote, LocalTime jetzt) {
        return angebote.stream()
                .filter(a -> a.freiePlaetze() > 0 && a.abfahrt().isAfter(jetzt))
                .map(a -> new Monitoreintrag(a.haltepunkt(), a.richtung(), a.abfahrt(), a.freiePlaetze()))
                .toList();
    }
}

// MonitorAnsicht.java
package de.mitfahrlabor.monitor;

import java.util.List;

/** Darstellung: macht aus Monitoreinträgen HTML. */
public class MonitorAnsicht {

    public String alsHtml(List<Monitoreintrag> eintraege) {
        StringBuilder html = new StringBuilder("<ul class=\"monitor\">\n");
        for (Monitoreintrag e : eintraege) {
            html.append("  <li>").append(e.haltepunkt()).append(" → ").append(e.richtung()).append(", ")
                .append(e.abfahrt()).append(" Uhr, ").append(e.freiePlaetze())
                .append(e.freiePlaetze() == 1 ? " Platz" : " Plätze").append("</li>\n");
        }
        return html.append("</ul>").toString();
    }
}

// Monitorseite.java
package de.mitfahrlabor.monitor;

import java.io.IOException;
import java.time.LocalTime;
import java.util.List;
import java.util.logging.Logger;

/** Ablauf: lesen lassen, auswählen lassen, darstellen lassen, protokollieren. */
public class Monitorseite {

    private static final Logger LOG = Logger.getLogger(Monitorseite.class.getName());

    private final AngebotsDatei datei;
    private final Monitorauswahl auswahl = new Monitorauswahl();
    private final MonitorAnsicht ansicht = new MonitorAnsicht();

    public Monitorseite(AngebotsDatei datei) {
        this.datei = datei;
    }

    public String erzeuge(LocalTime jetzt) throws IOException {
        List<Monitoreintrag> eintraege = auswahl.offeneAngebote(datei.alle(), jetzt);
        LOG.info(() -> "Monitor: " + eintraege.size() + " Angebote angezeigt");
        return ansicht.alsHtml(eintraege);
    }
}