Übungsaufgaben zum Refactoring: Code Smells erkennen und in sicheren Schritten umbauen

@Test
void speditionJeRad() {
    assertArrayEquals(new int[] {149412, 0, 9800, 30250, 189462},
            shop.abschliessen(List.of(menge(STADTRAD, 2), menge(LICHTSET, 2)), "SPEDITION", null, MAIL));
}

@Test
void speditionOhneRadKostetEinePauschale() {
    assertArrayEquals(new int[] {7563, 0, 4900, 2368, 14831}, shop.abschliessen(List.of(LICHTSET), "SPEDITION", null, MAIL));
}

@Test
void abholungMitRabattcode() {
    assertArrayEquals(new int[] {252017, 25202, 0, 43095, 269910}, shop.abschliessen(List.of(EBIKE), "ABHOLUNG", "KURIER10", MAIL));
}

@Test
void radAlsPaketWirdAbgelehnt() {
    assertThrows(IllegalArgumentException.class, () -> shop.abschliessen(List.of(STADTRAD), "PAKET", null, MAIL));
    assertEquals(0, shop.getPostausgang().size());
    assertEquals(0, shop.getBestellungen().size());
}

@Test
void unbekannteVersandartWirdAbgelehnt() {
    assertThrows(IllegalArgumentException.class, () -> shop.abschliessen(List.of(LICHTSET), "BRIEF", null, MAIL));
}

def test_spedition_je_rad(shop: Shop) -> None:
    assert shop.abschliessen([replace(STADTRAD, menge=2), replace(LICHTSET, menge=2)], "SPEDITION", None, MAIL) == [149412, 0, 9800, 30250, 189462]


def test_spedition_ohne_rad_kostet_eine_pauschale(shop: Shop) -> None:
    assert shop.abschliessen([LICHTSET], "SPEDITION", None, MAIL) == [7563, 0, 4900, 2368, 14831]


def test_abholung_mit_rabattcode(shop: Shop) -> None:
    assert shop.abschliessen([EBIKE], "ABHOLUNG", "KURIER10", MAIL) == [252017, 25202, 0, 43095, 269910]


def test_rad_als_paket_wird_abgelehnt(shop: Shop) -> None:
    with pytest.raises(ValueError):
        shop.abschliessen([STADTRAD], "PAKET", None, MAIL)
    assert shop.get_postausgang() == []
    assert shop.get_bestellungen() == []


def test_unbekannte_versandart_wird_abgelehnt(shop: Shop) -> None:
    with pytest.raises(ValueError):
        shop.abschliessen([LICHTSET], "BRIEF", None, MAIL)

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

import java.util.List;

/** Parameterobjekt: alles, was der Bestellabschluss als Eingabe braucht. */
public record Bestellanfrage(List<Position> positionen, String versandart, String gutscheincode, String kundenEmail) {
}

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

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

public class Shop {

    private static final int ERSTE_BESTELLNUMMER = 1001;
    private static final String GUTSCHEINCODE_KURIER = "KURIER10";
    private static final int GUTSCHEIN_RABATT_PROZENT = 10;
    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;
    private static final int MEHRWERTSTEUER_PROZENT = 19;

    private int naechsteBestellnummer = ERSTE_BESTELLNUMMER;
    private final List<Object[]> bestellungen = new ArrayList<>();
    private final List<String> postausgang = new ArrayList<>();

    public List<Object[]> getBestellungen() {
        return bestellungen;
    }

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

    /**
     * Berechnet die Beträge einer Bestellung, verschickt die Bestätigungsmail und speichert die Bestellung.
     *
     * @return {Warenwert, Rabatt, Versandkosten, Mehrwertsteuer, Gesamtbetrag} in Cent
     */
    public int[] abschliessen(Bestellanfrage anfrage) {
        int warenwert = berechneWarenwert(anfrage.positionen());
        int rabatt = berechneRabatt(warenwert, anfrage.gutscheincode());
        int versandkosten = berechneVersandkosten(anfrage.positionen(), anfrage.versandart(), warenwert - rabatt);
        if (warenwert == 0) {
            throw new IllegalArgumentException("Bestellung ohne Warenwert");
        }
        int nettobetrag = warenwert - rabatt + versandkosten;
        int mehrwertsteuer = berechneMehrwertsteuer(nettobetrag);
        int gesamtbetrag = nettobetrag + mehrwertsteuer;
        int bestellnummer = vergibBestellnummer();
        postausgang.add(erstelleMailtext(anfrage, bestellnummer, gesamtbetrag));
        bestellungen.add(new Object[] {"CSB-" + bestellnummer, anfrage.kundenEmail(), anfrage.positionen(), gesamtbetrag});
        return new int[] {warenwert, rabatt, versandkosten, mehrwertsteuer, gesamtbetrag};
    }

    private int berechneWarenwert(List<Position> positionen) {
        int warenwert = 0;
        for (Position position : positionen) {
            if (position.menge() <= 0) {
                throw new IllegalArgumentException("Menge muss positiv sein: " + position.artikelnr());
            }
            warenwert = warenwert + position.nettopreisCent() * position.menge();
        }
        return warenwert;
    }

    private int berechneRabatt(int warenwert, String gutscheincode) {
        if (GUTSCHEINCODE_KURIER.equals(gutscheincode)) {
            return prozentKaufmaennischGerundet(warenwert, GUTSCHEIN_RABATT_PROZENT);
        }
        return 0;
    }

    private int berechneVersandkosten(List<Position> positionen, String versandart, int warenwertNachRabatt) {
        switch (versandart) {
            case "PAKET":
                int anzahlPakete = berechneAnzahlPakete(positionen);
                if (warenwertNachRabatt >= VERSANDKOSTENFREI_AB_CENT) {
                    return 0;
                }
                return anzahlPakete * PAKETPAUSCHALE_CENT;
            case "SPEDITION":
                // ohne Rad wird eine Speditionspauschale berechnet
                return Math.max(1, zaehleRaeder(positionen)) * SPEDITION_JE_RAD_CENT;
            case "ABHOLUNG":
                return 0;
            default:
                throw new IllegalArgumentException("Unbekannte Versandart: " + versandart);
        }
    }

    private int berechneAnzahlPakete(List<Position> positionen) {
        int gesamtgewicht = 0;
        for (Position position : positionen) {
            if (position.istRad()) {
                throw new IllegalArgumentException("Räder können nicht als Paket versandt werden");
            }
            gesamtgewicht = gesamtgewicht + position.gewichtGramm() * position.menge();
        }
        int anzahlPakete = (gesamtgewicht + HOECHSTGEWICHT_PAKET_GRAMM - 1) / HOECHSTGEWICHT_PAKET_GRAMM;
        return Math.max(1, anzahlPakete);
    }

    private int zaehleRaeder(List<Position> positionen) {
        int anzahlRaeder = 0;
        for (Position position : positionen) {
            if (position.istRad()) {
                anzahlRaeder = anzahlRaeder + position.menge();
            }
        }
        return anzahlRaeder;
    }

    private int berechneMehrwertsteuer(int nettobetrag) {
        return prozentKaufmaennischGerundet(nettobetrag, MEHRWERTSTEUER_PROZENT);
    }

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

    private int vergibBestellnummer() {
        int bestellnummer = naechsteBestellnummer;
        naechsteBestellnummer = naechsteBestellnummer + 1;
        return bestellnummer;
    }

    private String erstelleMailtext(Bestellanfrage anfrage, int bestellnummer, int gesamtbetrag) {
        String mailtext = "An: " + anfrage.kundenEmail() + "\nBestellung CSB-" + bestellnummer + "\nGesamtbetrag: "
                + alsEuroText(gesamtbetrag);
        if (anfrage.versandart().equals("ABHOLUNG")) {
            return mailtext + "\nAbholung in der Werkstatt Bielefeld-Sennestadt";
        }
        return mailtext + "\nVersand: " + versandbezeichnung(anfrage.versandart());
    }

    private static String versandbezeichnung(String versandart) {
        return switch (versandart) {
            case "PAKET" -> "Paket";
            case "SPEDITION" -> "Spedition";
            default -> "Abholung";
        };
    }

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

// in den Tests ändert sich nur der Aufruf, zum Beispiel:
assertArrayEquals(new int[] {7563, 0, 690, 1568, 9821}, shop.abschliessen(new Bestellanfrage(List.of(LICHTSET), "PAKET", null, MAIL)));

# csbrad/bestellanfrage.py
from dataclasses import dataclass

from csbrad.position import Position


@dataclass(frozen=True)
class Bestellanfrage:
    """Parameterobjekt: alles, was der Bestellabschluss als Eingabe braucht."""

    positionen: list[Position]
    versandart: str
    gutscheincode: str | None
    kunden_email: str

# csbrad/shop.py
from csbrad.bestellanfrage import Bestellanfrage
from csbrad.position import Position

ERSTE_BESTELLNUMMER = 1001
GUTSCHEINCODE_KURIER = "KURIER10"
GUTSCHEIN_RABATT_PROZENT = 10
PAKETPAUSCHALE_CENT = 690
HOECHSTGEWICHT_PAKET_GRAMM = 31500
VERSANDKOSTENFREI_AB_CENT = 10000
SPEDITION_JE_RAD_CENT = 4900
MEHRWERTSTEUER_PROZENT = 19


class Shop:

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

    def get_bestellungen(self) -> list[list[object]]:
        return self._bestellungen

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

    def abschliessen(self, anfrage: Bestellanfrage) -> list[int]:
        """Berechnet die Beträge einer Bestellung, verschickt die Bestätigungsmail und speichert die Bestellung.

        Rückgabe: [Warenwert, Rabatt, Versandkosten, Mehrwertsteuer, Gesamtbetrag] in Cent.
        """
        warenwert = self._berechne_warenwert(anfrage.positionen)
        rabatt = self._berechne_rabatt(warenwert, anfrage.gutscheincode)
        versandkosten = self._berechne_versandkosten(anfrage.positionen, anfrage.versandart, warenwert - rabatt)
        if warenwert == 0:
            raise ValueError("Bestellung ohne Warenwert")
        nettobetrag = warenwert - rabatt + versandkosten
        mehrwertsteuer = self._berechne_mehrwertsteuer(nettobetrag)
        gesamtbetrag = nettobetrag + mehrwertsteuer
        bestellnummer = self._vergib_bestellnummer()
        self._postausgang.append(self._erstelle_mailtext(anfrage, bestellnummer, gesamtbetrag))
        self._bestellungen.append(["CSB-" + str(bestellnummer), anfrage.kunden_email, anfrage.positionen, gesamtbetrag])
        return [warenwert, rabatt, versandkosten, mehrwertsteuer, gesamtbetrag]

    def _berechne_warenwert(self, positionen: list[Position]) -> int:
        warenwert = 0
        for position in positionen:
            if position.menge <= 0:
                raise ValueError(f"Menge muss positiv sein: {position.artikelnr}")
            warenwert = warenwert + position.nettopreis_cent * position.menge
        return warenwert

    def _berechne_rabatt(self, warenwert: int, gutscheincode: str | None) -> int:
        if gutscheincode == GUTSCHEINCODE_KURIER:
            return _prozent_kaufmaennisch_gerundet(warenwert, GUTSCHEIN_RABATT_PROZENT)
        return 0

    def _berechne_versandkosten(self, positionen: list[Position], versandart: str, warenwert_nach_rabatt: int) -> int:
        match versandart:
            case "PAKET":
                anzahl_pakete = self._berechne_anzahl_pakete(positionen)
                if warenwert_nach_rabatt >= VERSANDKOSTENFREI_AB_CENT:
                    return 0
                return anzahl_pakete * PAKETPAUSCHALE_CENT
            case "SPEDITION":
                # ohne Rad wird eine Speditionspauschale berechnet
                return max(1, self._zaehle_raeder(positionen)) * SPEDITION_JE_RAD_CENT
            case "ABHOLUNG":
                return 0
            case _:
                raise ValueError(f"Unbekannte Versandart: {versandart}")

    def _berechne_anzahl_pakete(self, positionen: list[Position]) -> int:
        gesamtgewicht = 0
        for position in positionen:
            if position.ist_rad:
                raise ValueError("Räder können nicht als Paket versandt werden")
            gesamtgewicht = gesamtgewicht + position.gewicht_gramm * position.menge
        anzahl_pakete = (gesamtgewicht + HOECHSTGEWICHT_PAKET_GRAMM - 1) // HOECHSTGEWICHT_PAKET_GRAMM
        return max(1, anzahl_pakete)

    def _zaehle_raeder(self, positionen: list[Position]) -> int:
        anzahl_raeder = 0
        for position in positionen:
            if position.ist_rad:
                anzahl_raeder = anzahl_raeder + position.menge
        return anzahl_raeder

    def _berechne_mehrwertsteuer(self, nettobetrag: int) -> int:
        return _prozent_kaufmaennisch_gerundet(nettobetrag, MEHRWERTSTEUER_PROZENT)

    def _vergib_bestellnummer(self) -> int:
        bestellnummer = self._naechste_bestellnummer
        self._naechste_bestellnummer = self._naechste_bestellnummer + 1
        return bestellnummer

    def _erstelle_mailtext(self, anfrage: Bestellanfrage, bestellnummer: int, gesamtbetrag: int) -> str:
        mailtext = ("An: " + anfrage.kunden_email + "\nBestellung CSB-" + str(bestellnummer)
                    + "\nGesamtbetrag: " + _als_euro_text(gesamtbetrag))
        if anfrage.versandart == "ABHOLUNG":
            return mailtext + "\nAbholung in der Werkstatt Bielefeld-Sennestadt"
        return mailtext + "\nVersand: " + _versandbezeichnung(anfrage.versandart)


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


def _versandbezeichnung(versandart: str) -> str:
    return {"PAKET": "Paket", "SPEDITION": "Spedition"}.get(versandart, "Abholung")


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

# in den Tests ändert sich nur der Aufruf, zum Beispiel:
assert shop.abschliessen(Bestellanfrage([LICHTSET], "PAKET", None, MAIL)) == [7563, 0, 690, 1568, 9821]

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

class MonitoranzeigeTest {

    private final Monitoranzeige anzeige = new Monitoranzeige();

    @Test
    void kurzerHaltepunktMehrerePlaetze() {
        assertEquals("Bad Salzuflen | Busbahnhof | zum DBH | 07:05 | 3 Plätze frei",
                anzeige.zeile("Bad Salzuflen", "Busbahnhof", "zum DBH", 7, 5, 3));
    }

    @Test
    void langerHaltepunktWirdGekuerzt() {
        assertEquals("Gütersloh | Hauptbahnhof, ZOB... | zum DBH | 06:50 | 1 Platz frei",
                anzeige.zeile("Gütersloh", "Hauptbahnhof, ZOB Steig 3", "zum DBH", 6, 50, 1));
    }

    @Test
    void zweiterLangerHaltepunkt() {
        assertEquals("Herford | Park & Ride am Ba... | zum DBH | 07:00 | 2 Plätze frei",
                anzeige.zeile("Herford", "Park & Ride am Bahnhof", "zum DBH", 7, 0, 2));
    }

    @Test
    void ohneFreiePlaetzeAusgebucht() {
        assertEquals("Bielefeld | Bahnhof Brackwede | nach Hause | 15:30 | ausgebucht",
                anzeige.zeile("Bielefeld", "Bahnhof Brackwede", "nach Hause", 15, 30, 0));
    }
}

from monitoranzeige import Monitoranzeige

anzeige = Monitoranzeige()


def test_kurzer_haltepunkt_mehrere_plaetze() -> None:
    assert anzeige.zeile("Bad Salzuflen", "Busbahnhof", "zum DBH", 7, 5, 3) == \
        "Bad Salzuflen | Busbahnhof | zum DBH | 07:05 | 3 Plätze frei"


def test_langer_haltepunkt_wird_gekuerzt() -> None:
    assert anzeige.zeile("Gütersloh", "Hauptbahnhof, ZOB Steig 3", "zum DBH", 6, 50, 1) == \
        "Gütersloh | Hauptbahnhof, ZOB... | zum DBH | 06:50 | 1 Platz frei"


def test_zweiter_langer_haltepunkt() -> None:
    assert anzeige.zeile("Herford", "Park & Ride am Bahnhof", "zum DBH", 7, 0, 2) == \
        "Herford | Park & Ride am Ba... | zum DBH | 07:00 | 2 Plätze frei"


def test_ohne_freie_plaetze_ausgebucht() -> None:
    assert anzeige.zeile("Bielefeld", "Bahnhof Brackwede", "nach Hause", 15, 30, 0) == \
        "Bielefeld | Bahnhof Brackwede | nach Hause | 15:30 | ausgebucht"

// Monitorangebot.java
/** Parameterobjekt: alles, was eine Zeile auf dem Flurmonitor zeigt. */
public record Monitorangebot(String ort, String haltepunkt, String richtung, int stunde, int minute, int freiePlaetze) {
}

// Monitoranzeige.java
public class Monitoranzeige {

    private static final int HOECHSTLAENGE_HALTEPUNKT = 20;
    private static final String AUSLASSUNG = "...";

    public String zeile(Monitorangebot angebot) {
        return angebot.ort() + " | " + kuerzeHaltepunkt(angebot.haltepunkt()) + " | " + angebot.richtung() + " | "
                + alsUhrzeit(angebot.stunde(), angebot.minute()) + " | " + platzText(angebot.freiePlaetze());
    }

    private static String alsUhrzeit(int stunde, int minute) {
        return String.format("%02d:%02d", stunde, minute);
    }

    private static String kuerzeHaltepunkt(String haltepunkt) {
        if (haltepunkt.length() <= HOECHSTLAENGE_HALTEPUNKT) {
            return haltepunkt;
        }
        return haltepunkt.substring(0, HOECHSTLAENGE_HALTEPUNKT - AUSLASSUNG.length()) + AUSLASSUNG;
    }

    private static String platzText(int freiePlaetze) {
        if (freiePlaetze == 0) {
            return "ausgebucht";
        }
        if (freiePlaetze == 1) {
            return "1 Platz frei";
        }
        return freiePlaetze + " Plätze frei";
    }
}

// Aufruf in den Tests, zum Beispiel:
anzeige.zeile(new Monitorangebot("Bad Salzuflen", "Busbahnhof", "zum DBH", 7, 5, 3))

from dataclasses import dataclass

HOECHSTLAENGE_HALTEPUNKT = 20
AUSLASSUNG = "..."


@dataclass(frozen=True)
class Monitorangebot:
    """Parameterobjekt: alles, was eine Zeile auf dem Flurmonitor zeigt."""

    ort: str
    haltepunkt: str
    richtung: str
    stunde: int
    minute: int
    freie_plaetze: int


class Monitoranzeige:

    def zeile(self, angebot: Monitorangebot) -> str:
        return " | ".join([angebot.ort, _kuerze_haltepunkt(angebot.haltepunkt), angebot.richtung,
                           _als_uhrzeit(angebot.stunde, angebot.minute), _platz_text(angebot.freie_plaetze)])


def _als_uhrzeit(stunde: int, minute: int) -> str:
    return f"{stunde:02d}:{minute:02d}"


def _kuerze_haltepunkt(haltepunkt: str) -> str:
    if len(haltepunkt) <= HOECHSTLAENGE_HALTEPUNKT:
        return haltepunkt
    return haltepunkt[:HOECHSTLAENGE_HALTEPUNKT - len(AUSLASSUNG)] + AUSLASSUNG


def _platz_text(freie_plaetze: int) -> str:
    if freie_plaetze == 0:
        return "ausgebucht"
    if freie_plaetze == 1:
        return "1 Platz frei"
    return f"{freie_plaetze} Plätze frei"

# Aufruf in den Tests, zum Beispiel:
anzeige.zeile(Monitorangebot("Bad Salzuflen", "Busbahnhof", "zum DBH", 7, 5, 3))

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

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

class BuchungsdienstTest {

    private Fahrt fahrt;

    @BeforeEach
    void fahrtMitEinerAbgelehntenAnfrage() {
        fahrt = new Fahrt("Ben Richter", 3);
        fahrt.anfragen().add(new Anfrage("Aylin Kaya", "BESTAETIGT"));
        fahrt.anfragen().add(new Anfrage("Oksana Melnyk", "BESTAETIGT"));
        fahrt.anfragen().add(new Anfrage("Jonas Wolff", "ABGELEHNT"));
    }

    @Test
    void abgelehnteAnfrageBelegtKeinenPlatz() {
        assertTrue(new Buchungsdienst().bucheMitfahrt(fahrt, "Lukas Hofmann"));
    }

    @Test
    void danachIstDieFahrtAusgebucht() {
        new Buchungsdienst().bucheMitfahrt(fahrt, "Lukas Hofmann");
        assertFalse(new Buchungsdienst().bucheMitfahrt(fahrt, "Lina Hartwig"));
        assertEquals("ausgebucht", new Monitorfeed().platzanzeige(fahrt));
    }
}

import pytest

from mitfahrt import Anfrage, Buchungsdienst, Fahrt, Monitorfeed


@pytest.fixture
def fahrt() -> Fahrt:
    fahrt = Fahrt("Ben Richter", 3)
    fahrt.anfragen.append(Anfrage("Aylin Kaya", "BESTAETIGT"))
    fahrt.anfragen.append(Anfrage("Oksana Melnyk", "BESTAETIGT"))
    fahrt.anfragen.append(Anfrage("Jonas Wolff", "ABGELEHNT"))
    return fahrt


def test_abgelehnte_anfrage_belegt_keinen_platz(fahrt: Fahrt) -> None:
    assert Buchungsdienst().buche_mitfahrt(fahrt, "Lukas Hofmann")


def test_danach_ist_die_fahrt_ausgebucht(fahrt: Fahrt) -> None:
    Buchungsdienst().buche_mitfahrt(fahrt, "Lukas Hofmann")
    assert not Buchungsdienst().buche_mitfahrt(fahrt, "Lina Hartwig")
    assert Monitorfeed().platzanzeige(fahrt) == "ausgebucht"

// Anfragestatus.java
public enum Anfragestatus {
    OFFEN, BESTAETIGT, ABGELEHNT
}

// Anfrage.java
public record Anfrage(String name, Anfragestatus status) {

    /** Offene und bestätigte Anfragen halten einen Platz frei, abgelehnte nicht. */
    public boolean belegtPlatz() {
        return status != Anfragestatus.ABGELEHNT;
    }
}

// Fahrt.java
import java.util.ArrayList;
import java.util.List;

public class Fahrt {

    private final String fahrer;
    private final int plaetze;
    private final List<Anfrage> anfragen = new ArrayList<>();

    public Fahrt(String fahrer, int plaetze) {
        this.fahrer = fahrer;
        this.plaetze = plaetze;
    }

    public String fahrer() {
        return fahrer;
    }

    public void fuegeAnfrageHinzu(Anfrage anfrage) {
        anfragen.add(anfrage);
    }

    public int freiePlaetze() {
        int belegt = 0;
        for (Anfrage anfrage : anfragen) {
            if (anfrage.belegtPlatz()) {
                belegt = belegt + 1;
            }
        }
        return plaetze - belegt;
    }
}

// Buchungsdienst.java
public class Buchungsdienst {

    public boolean bucheMitfahrt(Fahrt fahrt, String name) {
        if (fahrt.freiePlaetze() == 0) {
            return false;
        }
        fahrt.fuegeAnfrageHinzu(new Anfrage(name, Anfragestatus.OFFEN));
        return true;
    }
}

// Monitorfeed.java
public class Monitorfeed {

    public String platzanzeige(Fahrt fahrt) {
        int frei = fahrt.freiePlaetze();
        if (frei == 0) {
            return "ausgebucht";
        }
        return frei + " frei";
    }
}

from dataclasses import dataclass, field
from enum import Enum


class Anfragestatus(Enum):
    OFFEN = "offen"
    BESTAETIGT = "bestätigt"
    ABGELEHNT = "abgelehnt"


@dataclass(frozen=True)
class Anfrage:
    name: str
    status: Anfragestatus

    def belegt_platz(self) -> bool:
        """Offene und bestätigte Anfragen halten einen Platz frei, abgelehnte nicht."""
        return self.status is not Anfragestatus.ABGELEHNT


@dataclass
class Fahrt:
    fahrer: str
    plaetze: int
    _anfragen: list[Anfrage] = field(default_factory=list)

    def fuege_anfrage_hinzu(self, anfrage: Anfrage) -> None:
        self._anfragen.append(anfrage)

    def freie_plaetze(self) -> int:
        belegt = sum(1 for anfrage in self._anfragen if anfrage.belegt_platz())
        return self.plaetze - belegt


class Buchungsdienst:

    def buche_mitfahrt(self, fahrt: Fahrt, name: str) -> bool:
        if fahrt.freie_plaetze() == 0:
            return False
        fahrt.fuege_anfrage_hinzu(Anfrage(name, Anfragestatus.OFFEN))
        return True


class Monitorfeed:

    def platzanzeige(self, fahrt: Fahrt) -> str:
        frei = fahrt.freie_plaetze()
        if frei == 0:
            return "ausgebucht"
        return f"{frei} frei"