diff --git a/LibrarySystem/UI/BibTest.java b/LibrarySystem/UI/BibTest.java deleted file mode 100644 index 0c62d36..0000000 --- a/LibrarySystem/UI/BibTest.java +++ /dev/null @@ -1,58 +0,0 @@ -/*package LibrarySystem.UI; - -import LibrarySystem.domain.benutzern.*; -import LibrarySystem.domain.medien.*; -import LibrarySystem.facade.*; - -import java.time.LocalDate; - -// Testklasse zum Erstellen und Verwalten von Benutzern -public class BibTest { - public static void main(String[] args) { - - // Bibliothekssystem initialisieren - BibliothekSystem system = new BibliothekSystem(); - - // Benutzer erstellen - Benutzer erwachsener = new Erwachsener("Max", 35); - Benutzer student = new Student("Anna", 21); - Admin admin = new Admin("Lisa Admin", 40); - - system.benutzerRegistrieren(erwachsener); - system.benutzerRegistrieren(student); - - // Medien erstellen - Medium buch = new Buch("123", "Java Programmieren", "BP", 2020,"Buch"); - Medium dvd = new DVD("456", "Der große Film", "JP",2018, "DVD"); - - // Datum setzen und Ausleihe simulieren - system.datumAendern(LocalDate.of(2024, 11, 10)); - erwachsener.ausleihen(buch, system.getAktuellesDatum()); - student.ausleihen(dvd, system.getAktuellesDatum()); - system.zeigeGebuehren(erwachsener); - - - // Rückgabe simulieren - system.datumAendern(LocalDate.of(2024, 12, 15)); // Datum ändern - student.rueckgabe("456", system.getAktuellesDatum()); - - //Bezahlung der Gebühren simulieren - system.zeigeGebuehren(erwachsener); - admin.bestaetigeGebuehrenzahlung(erwachsener); - system.zeigeGebuehren(erwachsener); - - // Medien eines Benutzers anzeigen - erwachsener.anzeigenAusleihen(); - - // Benutzerinformationen anzeigen - System.out.println(erwachsener); - System.out.println("Jahresgebühr: " + erwachsener.getJahresgebuehr() + " EUR"); - - System.out.println(student); - System.out.println("Jahresgebühr: " + student.getJahresgebuehr() + " EUR"); - - System.out.println(admin); - System.out.println("Jahresgebühr: " + admin.getJahresgebuehr() + " EUR"); - - } -}*/ \ No newline at end of file diff --git a/LibrarySystem/UI/UI.java b/LibrarySystem/UI/UI.java index d339406..5932b5f 100644 --- a/LibrarySystem/UI/UI.java +++ b/LibrarySystem/UI/UI.java @@ -3,6 +3,9 @@ package LibrarySystem.UI; import LibrarySystem.domain.benutzern.*; import LibrarySystem.facade.BibliothekSystem; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Date; import java.util.Scanner; public class UI { @@ -24,6 +27,7 @@ public class UI { System.out.println("5. Zeige ausgeliehene Medien und Gebühren"); System.out.println("6. Verlängern der Leihfrist"); System.out.println("7. Admin-Login (Überfällige Gebühren verbuchen)"); + System.out.println("8. Systemdatum manuell ändern."); System.out.println("0. Beenden\n"); System.out.print("Bitte wählen Sie eine Option: "); int auswahl = scanner.nextInt(); @@ -37,6 +41,7 @@ public class UI { case 5 -> zeigeAusgelieheneMedienUndGebuehren(); case 6 -> verlaengernLeihfrist(); case 7 -> adminLogin(); + case 8 -> aendernDatumManuell(); case 0 -> { System.out.println("Auf Wiedersehen!"); return; @@ -122,6 +127,18 @@ public class UI { } } + private void aendernDatumManuell(){ + System.out.println("Neues Datum eingeben (Format: yyyy-MM-dd)"); + String datum = scanner.nextLine(); + try{ + SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd"); + Date neuesDatum = formatter.parse(datum); + system.setAktuellesDatum(neuesDatum); + } catch (ParseException e) { + System.out.println("Üngultiges Datum."); + } + } + } diff --git a/LibrarySystem/andereDateien/KIchatGPT/prompt1.txt b/LibrarySystem/andereDateien/KIchatGPT/prompt1.txt new file mode 100644 index 0000000..749974a --- /dev/null +++ b/LibrarySystem/andereDateien/KIchatGPT/prompt1.txt @@ -0,0 +1,13 @@ +ich: Erstelle mir eine Methode findeMedium, die in einer Liste mit Medien ein bestimmtes, vom Benutzer eingegebenen Medium +findet. Benutze dabei Lambda-Ausdrücke + +AI: hier ist die Methode findeMedium, in einer Liste von Medien nach einem bestimmten, vom Benutzer eingegebenen Medium +findet: + +//Methode zum Finden eines Mediums + public Medium findeMedium(String ID) { + return medienListe.stream() + .filter(m -> m.getID().equals(ID)) + .findFirst() + .orElse(null); + } \ No newline at end of file diff --git a/LibrarySystem/andereDateien/KIchatGPT/prompt2+3.txt b/LibrarySystem/andereDateien/KIchatGPT/prompt2+3.txt new file mode 100644 index 0000000..6866030 --- /dev/null +++ b/LibrarySystem/andereDateien/KIchatGPT/prompt2+3.txt @@ -0,0 +1,220 @@ +prompt 2: + +ich: erstelle eine Methode overdueGebuehren, die die überfälligen Gebühren berechnet. hier ist die Einsatzklasse +(Klasse BibliothekSystem): + +AI: Methode: calculateOverdueFee + Diese Methode berechnet die überfälligen Gebühren basierend auf den Anzahl der überfälligen Tage. + Die Berechnung erfolgt nach einer einfachen Regel: 0,50 EUR pro überfälligem Tag. + + Code + java + + // Berechnung der Gebühren für überfällige Medien + private double calculateOverdueFee(long overdueDays) { + return overdueDays * 0.50; // Beispiel: 0,50 EUR pro Tag + } + + + Einsatzort + Die Methode wird innerhalb von returnMedium aufgerufen, um die Gebühren zu berechnen: + + java + if (currentDate.after(medium.getDueDate())) { + long overdueDays = (currentDate.getTime() - medium.getDueDate().getTime()) / (1000 * 60 * 60 * 24); + double fee = calculateOverdueFee(overdueDays); + System.out.println("Überfällige Gebühren für " + borrower.getName() + ": " + fee + " EUR."); + } + + Einbindung in die LibrarySystem-Klasse + Die Methode ist eine private Hilfsmethode der LibrarySystem-Klasse, da sie nur für interne Berechnungen verwendet wird. + Sie ist bewusst einfach gehalten, kann aber bei Bedarf erweitert werden, + z. B. um unterschiedliche Gebühren für verschiedene Medientypen oder Benutzerkategorien zu berücksichtigen. + +----------------------------------------------------------- +prompt 3: + +ich: Das System soll überfällige Artikel verfolgen und Säumnisgebühren berechnen: • Für jeden Tag, an dem ein Gegenstand + überfällig ist, wird eine Gebühr von 1€ erhoben. • Nach 7 Tagen Überfälligkeit erhöht sich die Gebühr auf 2€ pro Tag. + Das System sollte den Benutzern die Gesamtgebühren jedes Mal anzeigen, wenn sie sich anmelden, einen Artikel ausleihen + oder zurückgeben. + + AI: Um diese Anforderungen umzusetzen, wird das Bibliotheksverwaltungssystem wie folgt erweitert: + + 1. Überarbeitung von calculateOverdueFee + Die Methode calculateOverdueFee wird angepasst, um die gestaffelten Gebühren zu berücksichtigen: + + java + Copy code + private double calculateOverdueFee(long overdueDays) { + if (overdueDays <= 0) { + return 0; // Keine Gebühren, wenn nicht überfällig + } + + if (overdueDays <= 7) { + return overdueDays * 1.0; // 1€ pro Tag für die ersten 7 Tage + } + + return (7 * 1.0) + ((overdueDays - 7) * 2.0); // 2€ pro Tag ab dem 8. Tag + } + 2. Verfolgung von Gebühren pro Benutzer + Die Klasse User wird erweitert, um aufgelaufene Gebühren zu speichern und zu verwalten: + + Anpassung der User-Klasse + java + Copy code + public class User { + private String id; + private String name; + private List borrowedItems; + private double outstandingFees; // Aufgelaufene Gebühren + + public User(String id, String name) { + this.id = id; + this.name = name; + this.borrowedItems = new ArrayList<>(); + this.outstandingFees = 0.0; + } + + public double getOutstandingFees() { + return outstandingFees; + } + + public void addFee(double fee) { + this.outstandingFees += fee; + } + + public void clearFees() { + this.outstandingFees = 0.0; + } + + public void listBorrowedItems() { + if (borrowedItems.isEmpty()) { + System.out.println("Keine ausgeliehenen Medien."); + } else { + System.out.println("Ausgeliehene Medien:"); + for (Medium medium : borrowedItems) { + System.out.println("- " + medium.getTitle() + " (Rückgabedatum: " + medium.getDueDate() + ")"); + } + } + } + + // Weitere Methoden für Ausleihen und Rückgabe wie bereits implementiert + } + 3. Gebührenberechnung bei Rückgabe + Die Methode returnMedium wird angepasst, um aufgelaufene Gebühren direkt in der Benutzerinstanz zu speichern: + + java + Copy code + public void returnMedium(String mediumId) { + Medium medium = findMedium(mediumId); + if (medium == null) { + System.out.println("Medium mit der ID '" + mediumId + "' wurde nicht gefunden."); + return; + } + + if (!medium.isLoaned()) { + System.out.println("Medium '" + medium.getTitle() + "' ist nicht ausgeliehen."); + return; + } + + User borrower = null; + for (User user : userManager.getUsers()) { + if (user.getBorrowedItems().contains(medium)) { + borrower = user; + break; + } + } + + if (borrower == null) { + System.out.println("Kein Benutzer gefunden, der dieses Medium ausgeliehen hat."); + return; + } + + borrower.returnItem(medium); + + // Überfällige Gebühren berechnen + if (currentDate.after(medium.getDueDate())) { + long overdueDays = (currentDate.getTime() - medium.getDueDate().getTime()) / (1000 * 60 * 60 * 24); + double fee = calculateOverdueFee(overdueDays); + borrower.addFee(fee); + System.out.println("Medium '" + medium.getTitle() + "' wurde erfolgreich zurückgegeben."); + System.out.println("Überfällige Gebühren für " + borrower.getName() + ": " + fee + " EUR."); + } else { + System.out.println("Medium '" + medium.getTitle() + "' wurde rechtzeitig zurückgegeben."); + } + + // Verbleibende ausgeliehene Medien anzeigen + System.out.println("Verbleibende ausgeliehene Medien von " + borrower.getName() + ":"); + borrower.listBorrowedItems(); + } + 4. Gebührenanzeige bei Anmeldung + Eine Methode wird hinzugefügt, um die Gebühren eines Benutzers bei der Anmeldung anzuzeigen: + + java + Copy code + public void showOutstandingFees(String userId) { + User user = userManager.getUser(userId); + if (user == null) { + System.out.println("Benutzer nicht gefunden."); + return; + } + + double fees = user.getOutstandingFees(); + if (fees > 0) { + System.out.println("Offene Gebühren für " + user.getName() + ": " + fees + " EUR."); + } else { + System.out.println("Keine offenen Gebühren für " + user.getName() + "."); + } + } + 5. Gebührenzahlung durch Admin + Ein Admin-Benutzer wird hinzugefügt, der Zahlungen bearbeiten kann: + + Admin-Klasse + java + Copy code + public class Admin extends User { + public Admin(String id, String name) { + super(id, name); + } + + public void processPayment(User user, double amount) { + if (amount <= 0) { + System.out.println("Ungültiger Zahlungsbetrag."); + return; + } + + if (amount > user.getOutstandingFees()) { + System.out.println("Betrag übersteigt offene Gebühren."); + return; + } + + user.addFee(-amount); // Reduziert die Gebühren + System.out.println("Zahlung von " + amount + " EUR für " + user.getName() + " erfolgreich bearbeitet."); + System.out.println("Verbleibende Gebühren: " + user.getOutstandingFees() + " EUR."); + } + } + Gebührenzahlung + Die Benutzeroberfläche wird um eine Option für Admins ergänzt: + + java + Copy code + case 6 -> { + System.out.print("Admin-ID: "); + String adminId = scanner.next(); + User admin = userManager.getUser(adminId); + if (admin instanceof Admin) { + System.out.print("Benutzer-ID: "); + String userId = scanner.next(); + User user = userManager.getUser(userId); + if (user == null) { + System.out.println("Benutzer nicht gefunden."); + break; + } + System.out.print("Zahlungsbetrag: "); + double amount = scanner.nextDouble(); + ((Admin) admin).processPayment(user, amount); + } else { + System.out.println("Keine Admin-Rechte."); + } + } \ No newline at end of file diff --git a/LibrarySystem/andereDateien/KIchatGPT/prompt4+5.txt b/LibrarySystem/andereDateien/KIchatGPT/prompt4+5.txt new file mode 100644 index 0000000..3fd4531 --- /dev/null +++ b/LibrarySystem/andereDateien/KIchatGPT/prompt4+5.txt @@ -0,0 +1,173 @@ +prompt 4: + +ich: implementiere einen weiteren punkt in die ui, der eine manuelle systemdatumänderung erlaubt, +um die rückgabe mit gebührenkonto ausprobieren zu können. Hier ist die UI Klasse (Eingabe von UI Klasse) + +AI:Um eine manuelle Änderung des Systemdatums in der Benutzeroberfläche zu ermöglichen, müssen folgende Schritte durchgeführt werden: + + 1. Hinzufügen eines Systemdatums + Ein globales Systemdatum wird hinzugefügt, das in der gesamten Anwendung verwendet wird. Dies ermöglicht es, das Datum manuell zu ändern. + + Hinzufügen zur LibrarySystem-Klasse + java + Copy code + import java.util.Calendar; + import java.util.Date; + + public class LibrarySystem { + private Date currentDate; + + public LibrarySystem() { + this.currentDate = new Date(); // Standardmäßig aktuelles Datum + } + + public Date getCurrentDate() { + return currentDate; + } + + public void setCurrentDate(Date date) { + this.currentDate = date; + System.out.println("Systemdatum erfolgreich auf " + date + " geändert."); + } + + public void resetCurrentDate() { + this.currentDate = new Date(); + System.out.println("Systemdatum auf aktuelles Datum zurückgesetzt: " + currentDate); + } + } + 2. Anpassung der Berechnungen + Die Methoden, die auf das aktuelle Datum angewiesen sind (z. B. Rückgabefristen und Gebührenberechnung), nutzen nun das globale currentDate. + + Beispiel: returnMedium + java + Copy code + if (currentDate.after(medium.getDueDate())) { + long overdueDays = (currentDate.getTime() - medium.getDueDate().getTime()) / (1000 * 60 * 60 * 24); + double fee = calculateOverdueFee(overdueDays); + borrower.addFee(fee); + System.out.println("Medium '" + medium.getTitle() + "' wurde erfolgreich zurückgegeben."); + System.out.println("Überfällige Gebühren für " + borrower.getName() + ": " + fee + " EUR."); + } + 3. Erweiterung der Benutzeroberfläche + Eine neue Option wird hinzugefügt, um das Datum manuell zu ändern oder zurückzusetzen. + + Code für die UI: + java + Copy code + case 7 -> { + System.out.println("Systemdatum ändern:"); + System.out.println("1. Manuelles Datum setzen"); + System.out.println("2. Datum auf aktuelles zurücksetzen"); + int option = scanner.nextInt(); + + switch (option) { + case 1 -> { + System.out.print("Neues Datum eingeben (Format: yyyy-MM-dd): "); + String dateInput = scanner.next(); + try { + SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd"); + Date newDate = dateFormat.parse(dateInput); + librarySystem.setCurrentDate(newDate); + } catch (ParseException e) { + System.out.println("Ungültiges Datum. Bitte im Format yyyy-MM-dd eingeben."); + } + } + case 2 -> librarySystem.resetCurrentDate(); + default -> System.out.println("Ungültige Option."); + } + } +--------------------------------------------------------------------- +prompt 5: + +ich: das rückgabeDatum wird bei mir so berechnet, sodass immer das systemdatum verwendet wird. kannst du das so verbessern, +so dass es auch mit dem manuellen Datum funktioniert? public Date rechneRueckgabedatum(){ + Calendar calendar = Calendar.getInstance(); + calendar.add(Calendar.DAY_OF_YEAR, getAusleihdauer()); + this.rueckgabedatum = calendar.getTime(); + return rueckgabedatum; + } +AI: + Um sicherzustellen, dass die Methode rechneRueckgabedatum mit dem manuellen Systemdatum arbeitet, anstatt immer + das aktuelle Datum zu verwenden, können wir das globale Systemdatum aus der LibrarySystem-Klasse einbinden. + Dazu müssen wir das Systemdatum explizit in die Berechnung einfließen lassen. + + Verbesserte Implementierung der Methode + java + Copy code + public Date rechneRueckgabedatum(Date systemDate) { + Calendar calendar = Calendar.getInstance(); + calendar.setTime(systemDate); // Verwende das übergebene Systemdatum + calendar.add(Calendar.DAY_OF_YEAR, getAusleihdauer()); // Füge die Ausleihdauer hinzu + this.rueckgabedatum = calendar.getTime(); + return rueckgabedatum; + } + Anpassung der Aufrufe + Damit die Methode korrekt funktioniert, muss das Systemdatum beim Aufruf übergeben werden. Beispielsweise: + + Ausleihe eines Mediums + Wenn ein Medium ausgeliehen wird, rufst du rechneRueckgabedatum mit dem aktuellen Systemdatum auf: + + java + Copy code + public void leiheMediumAus(Medium medium) { + if (medium.isLoaned()) { + System.out.println("Das Medium '" + medium.getTitle() + "' ist bereits ausgeliehen."); + return; + } + + Date rueckgabeDatum = medium.rechneRueckgabedatum(librarySystem.getCurrentDate()); + medium.setLoaned(true); + medium.setDueDate(rueckgabeDatum); + System.out.println("Medium '" + medium.getTitle() + "' erfolgreich ausgeliehen."); + System.out.println("Rückgabedatum: " + rueckgabeDatum); + } + Alternative: Systemdatum global bereitstellen + Falls viele Klassen das Systemdatum verwenden, kannst du es direkt über eine Singleton-Instanz der LibrarySystem-Klasse bereitstellen: + + Singleton-Pattern für LibrarySystem + java + Copy code + public class LibrarySystem { + private static LibrarySystem instance; + private Date currentDate; + + private LibrarySystem() { + this.currentDate = new Date(); + } + + public static LibrarySystem getInstance() { + if (instance == null) { + instance = new LibrarySystem(); + } + return instance; + } + + public Date getCurrentDate() { + return currentDate; + } + + public void setCurrentDate(Date date) { + this.currentDate = date; + } + + public void resetCurrentDate() { + this.currentDate = new Date(); + } + } + Aufruf ohne Übergabe des Datums + Wenn die Methode auf das Singleton zugreifen kann, wird die Übergabe des Datums überflüssig: + + java + Copy code + public Date rechneRueckgabedatum() { + Calendar calendar = Calendar.getInstance(); + calendar.setTime(LibrarySystem.getInstance().getCurrentDate()); + calendar.add(Calendar.DAY_OF_YEAR, getAusleihdauer()); + this.rueckgabedatum = calendar.getTime(); + return rueckgabedatum; + } + Zusammenfassung der Änderungen + Neue Methode: Die Methode rechneRueckgabedatum akzeptiert jetzt ein systemDate als Parameter. + Systemweite Änderungen: Das Systemdatum wird durch die LibrarySystem-Klasse verwaltet. + Globale Verfügbarkeit: Entweder durch explizite Übergabe oder über ein Singleton-Pattern. + Mit diesen Änderungen passt sich das Rückgabedatum automatisch an das manuelle Systemdatum an. \ No newline at end of file diff --git a/LibrarySystem/andereDateien/KIchatGPT/prompt6.txt b/LibrarySystem/andereDateien/KIchatGPT/prompt6.txt new file mode 100644 index 0000000..c2f7e87 --- /dev/null +++ b/LibrarySystem/andereDateien/KIchatGPT/prompt6.txt @@ -0,0 +1,123 @@ + +ich: wie kann ich die jährliche Gebühren, die jeweils in den klassen Erwachsener und Student als final JAHRESGEBUEHREN, +mit in das gebührenkonto mitrechnen + +AI: Um die jährlichen Gebühren (JAHRESGEBUEHREN) aus den Klassen Erwachsener und Student in das Gebührenkonto eines +Benutzers einzurechnen, kannst du folgende Schritte unternehmen: + +1. Änderungen in den Klassen Erwachsener und Student +Die Klassen sollten eine Methode bereitstellen, um die jährlichen Gebühren abzurufen. Wenn sie final sind, kann dies einfach ein Getter sein. + +Beispiel: Klasse Erwachsener +java +Copy code +public class Erwachsener extends Benutzer { + public static final double JAHRESGEBUEHREN = 50.0; // Beispielwert + + @Override + public double getJahresgebuehren() { + return JAHRESGEBUEHREN; + } +} +Beispiel: Klasse Student +java +Copy code +public class Student extends Benutzer { + public static final double JAHRESGEBUEHREN = 25.0; // Beispielwert + + @Override + public double getJahresgebuehren() { + return JAHRESGEBUEHREN; + } +} +2. Anpassung der Basisklasse Benutzer +In der Basisklasse Benutzer solltest du eine Methode getJahresgebuehren() deklarieren, die von den Unterklassen überschrieben wird. + +Klasse Benutzer +java +Copy code +public abstract class Benutzer { + private double gebuehrenkonto; // Das Konto, das alle Gebühren summiert + + public Benutzer() { + this.gebuehrenkonto = 0.0; // Initialisierung + } + + // Abstrakte Methode, die von Unterklassen implementiert wird + public abstract double getJahresgebuehren(); + + // Methode, um Gebühren hinzuzufügen + public void addGebuehren(double betrag) { + this.gebuehrenkonto += betrag; + } + + // Methode, um das Gebührenkonto abzurufen + public double getGebuehrenkonto() { + return gebuehrenkonto; + } + + // Methode, um die Jahresgebühr hinzuzufügen + public void berechneJahresgebuehren() { + addGebuehren(getJahresgebuehren()); + } +} +3. Automatische Einrechnung der Jahresgebühren +Du kannst sicherstellen, dass die jährlichen Gebühren beim Erstellen eines Benutzers automatisch eingerechnet werden, +oder sie beim Jahreswechsel explizit einberechnen. + +Beispiel: Automatische Berechnung bei Benutzererstellung +Passe die Konstruktoren der Unterklassen an, um die Jahresgebühren direkt hinzuzufügen: + +java +Copy code +public class Erwachsener extends Benutzer { + public static final double JAHRESGEBUEHREN = 50.0; + + public Erwachsener() { + super(); // Ruft den Konstruktor von Benutzer auf + berechneJahresgebuehren(); // Hinzufügen der Jahresgebühr + } + + @Override + public double getJahresgebuehren() { + return JAHRESGEBUEHREN; + } +} +4. Beispiel für manuelle Einrechnung bei Jahreswechsel +Wenn die Jahresgebühren zu einem bestimmten Zeitpunkt eingerechnet werden sollen, kannst du eine Methode +in der Klasse BibliothekSystem hinzufügen: + +Methode in BibliothekSystem +java +Copy code +public void berechneJahresgebuehrenFuerAlleBenutzer(List benutzerListe) { + for (Benutzer benutzer : benutzerListe) { + benutzer.berechneJahresgebuehren(); + } +} +Aufruf der Methode +java +Copy code +BibliothekSystem bibliothekSystem = BibliothekSystem.getInstance(); +bibliothekSystem.berechneJahresgebuehrenFuerAlleBenutzer(benutzerListe); +5. Aktualisierung des Gebührenkontos bei Aktionen +Das System kann die Jahresgebühren im Gebührenkonto automatisch berücksichtigen, wenn der Benutzer sein Konto abruft: + +Aktualisierung bei Kontoabfrage +java +Copy code +public double getGesamtgebuehren() { + return getGebuehrenkonto(); // Gebührensaldo inklusive Jahresgebühren +} +6. Ausgabe für den Benutzer +Die Gebühren können bei jeder Benutzerinteraktion angezeigt werden, z. B. bei der Anmeldung: + +java +Copy code +System.out.println("Ihre Gesamtgebühren betragen: " + benutzer.getGesamtgebuehren() + "€"); +Zusammenfassung +Die jährlichen Gebühren werden über die Methode getJahresgebuehren() aus den Unterklassen abgerufen. +Die Methode berechneJahresgebuehren() fügt die Gebühren zum Konto des Benutzers hinzu. +Entweder bei der Erstellung eines Benutzers oder zu einem bestimmten Zeitpunkt (z. B. Jahreswechsel) werden die Gebühren berechnet. +Das Gebührenkonto wird automatisch aktualisiert und bei Benutzeraktionen angezeigt. +Mit dieser Struktur bleibt das System flexibel und wartbar. \ No newline at end of file diff --git a/LibrarySystem/domain/benutzern/Benutzer.java b/LibrarySystem/domain/benutzern/Benutzer.java index 9d8843b..5bc2407 100644 --- a/LibrarySystem/domain/benutzern/Benutzer.java +++ b/LibrarySystem/domain/benutzern/Benutzer.java @@ -21,7 +21,7 @@ public abstract class Benutzer { //Getter und Setter public String getKartennummer() {return kartennummer;} - public void setkartennummer(String kartennummer) {this.kartennummer = kartennummer;} + public void setKartennummer(String kartennummer) {this.kartennummer = kartennummer;} public String getName() {return name;} public void setName(String name) {this.name = name;} public int getAlter() {return alter;} @@ -42,7 +42,6 @@ public abstract class Benutzer { } else{ System.out.println("Das Medium ist bereits ausgeliehen."); } - //gebuehrenBezahlt = false; // Neue Ausleihe bedeutet potenziell offene Gebühren } //Methode für die Rückgabe @@ -69,12 +68,19 @@ public abstract class Benutzer { } } - public double addiereZuOffeneGebuehren(double gebuehren){ - return this.offeneGebuehren+= gebuehren; + //Methode zum Addieren der Gebühren zu den offenen Gebühren + public void addiereZuOffeneGebuehren(double gebuehren){ + this.offeneGebuehren+= gebuehren; + } + + //Methode für den Admin, um nach eine erfolgreiche Bezahlung das Konto auf 0 zu setzen + public void bezahleGebuehren() { + offeneGebuehren = 0.0; } - /*public void aktualisiereGebuehren(Date aktuellesDatum) { + + /*public void aktualisiereGebuehren(Date aktuellesDatum) { if (gebuehrenBezahlt) return; // Keine Aktualisierung erforderlich, wenn bezahlt offeneGebuehren = 0.0; for (Medium ausleihe : ausleihen) { @@ -82,13 +88,6 @@ public abstract class Benutzer { } }*/ - public void bezahleGebuehren() { - offeneGebuehren = 0.0; - } - - - - @Override public String toString() { return "Name: " + name + ", Alter: " + alter + ", Kartennummer: " + kartennummer; diff --git a/LibrarySystem/domain/medien/Brettspiel.java b/LibrarySystem/domain/medien/Brettspiel.java index 66ecbb9..922837b 100644 --- a/LibrarySystem/domain/medien/Brettspiel.java +++ b/LibrarySystem/domain/medien/Brettspiel.java @@ -19,10 +19,4 @@ public class Brettspiel extends Medium { return false; //Keine Verlängerung } - @Override - public int verlaengern() { - System.out.println("Brettspiele können nicht verlängert werden."); - return 0; - } - } diff --git a/LibrarySystem/domain/medien/Buch.java b/LibrarySystem/domain/medien/Buch.java index e893af4..337edca 100644 --- a/LibrarySystem/domain/medien/Buch.java +++ b/LibrarySystem/domain/medien/Buch.java @@ -1,7 +1,6 @@ package LibrarySystem.domain.medien; - public class Buch extends Medium { private static final int AUSLEIHDAUER = 28; //4 Wochen in Tagen //private int verlaengerungenBuch = 3; @@ -21,16 +20,4 @@ public class Buch extends Medium { return verlaengerungen >0; } - @Override - public int verlaengern() { - if (istVerlaengerbar()) { - verlaengerungen--; - rechneRueckgabedatum(); //Verlängerung - } else{ - System.out.println("Keine Verlängerung mehr möglich."); - } - return verlaengerungen; - - } - } diff --git a/LibrarySystem/domain/medien/CD.java b/LibrarySystem/domain/medien/CD.java index bd0a683..f02263c 100644 --- a/LibrarySystem/domain/medien/CD.java +++ b/LibrarySystem/domain/medien/CD.java @@ -18,10 +18,4 @@ public class CD extends Medium { return false; } - @Override - public int verlaengern() { - System.out.println("CDs können nicht verlängert werden."); - return 0; - } - } diff --git a/LibrarySystem/domain/medien/DVD.java b/LibrarySystem/domain/medien/DVD.java index 636f755..fc8ee29 100644 --- a/LibrarySystem/domain/medien/DVD.java +++ b/LibrarySystem/domain/medien/DVD.java @@ -18,11 +18,11 @@ public class DVD extends Medium { return false; //Keine Verlängerung } - @Override + /*@Override public int verlaengern() { System.out.println("DVDs können nicht verlängert werden."); return 0; - } + }*/ } diff --git a/LibrarySystem/domain/medien/Medium.java b/LibrarySystem/domain/medien/Medium.java index 346cb5c..490093a 100644 --- a/LibrarySystem/domain/medien/Medium.java +++ b/LibrarySystem/domain/medien/Medium.java @@ -62,8 +62,9 @@ public abstract class Medium implements Ausleihbar{ public void setVerlaengerungen(int verlaengerungen) {} //Andere nützliche Methoden - public Date rechneRueckgabedatum(){ + public Date rechneRueckgabedatum(Date systemDatum){ Calendar calendar = Calendar.getInstance(); + calendar.setTime(systemDatum); calendar.add(Calendar.DAY_OF_YEAR, getAusleihdauer()); this.rueckgabedatum = calendar.getTime(); return rueckgabedatum; @@ -72,13 +73,11 @@ public abstract class Medium implements Ausleihbar{ //Abstrakte Methoden public abstract int getAusleihdauer(); public abstract boolean istVerlaengerbar(); - public abstract int verlaengern(); @Override public void ausleihen() { if(!istAusgeliehen()){ setAusgeliehen(); - rechneRueckgabedatum(); } else{ System.out.println("Medium ist bereits ausgeliehen."); } diff --git a/LibrarySystem/domain/medien/Videospiel.java b/LibrarySystem/domain/medien/Videospiel.java index e838b8e..caef14f 100644 --- a/LibrarySystem/domain/medien/Videospiel.java +++ b/LibrarySystem/domain/medien/Videospiel.java @@ -18,15 +18,15 @@ public class Videospiel extends Medium { return verlaengerungen>0; } - @Override + /*@Override public int verlaengern() { if (istVerlaengerbar()){ verlaengerungen--; - rechneRueckgabedatum(); //Verlängerung + //rechneRueckgabedatum(); //Verlängerung } else { System.out.println("Keine Verlängerung mehr möglich"); } return verlaengerungen; - } + }*/ } diff --git a/LibrarySystem/facade/BibliothekSystem.java b/LibrarySystem/facade/BibliothekSystem.java index 3f1e7e0..d2dc41e 100644 --- a/LibrarySystem/facade/BibliothekSystem.java +++ b/LibrarySystem/facade/BibliothekSystem.java @@ -11,7 +11,7 @@ import java.util.stream.Collectors; public class BibliothekSystem { private List benutzerListe; - private Date aktuellesDatum; + private Date aktuellesDatum; //Standardmäßig aktuelles Datum private List medienListe; public BibliothekSystem() { @@ -100,7 +100,7 @@ public class BibliothekSystem { Medium medium = findeMedium(mediumID); if (benutzer != null && medium != null && !medium.istAusgeliehen()) { benutzer.ausleihen(medium); - medium.setRueckgabedatum(medium.rechneRueckgabedatum()); + medium.setRueckgabedatum(medium.rechneRueckgabedatum(aktuellesDatum)); System.out.println(benutzer.getName() + " hat " + medium.getTitel() + " ausgeliehen."); System.out.println("Rückgabedatum: " + medium.getRueckgabedatum()); System.out.println("Verlängerungen möglich insgesamt: " + medium.getVerlaengerungen()); @@ -134,26 +134,27 @@ public class BibliothekSystem { System.out.println("Kein Benutzer gefunden, der dieses Medium ausgeliehen hat."); return; } - //Medium zurückgeben - try { - ausleiher.rueckgabe(medium); - System.out.println("Medium '"+medium.getTitel()+"' wurde erfolgreich am " + getAktuellesDatum() + " zurückgegeben."); + ausleiher.rueckgabe(medium); + System.out.println("Medium '"+medium.getTitel()+"' wurde erfolgreich am " + getAktuellesDatum() + " zurückgegeben."); + + //Für die Angabe des Gebührenkontos + //Von AI teilweise generiert if(aktuellesDatum.after(medium.getRueckgabedatum())){ long overdueTage = (aktuellesDatum.getTime() - medium.getRueckgabedatum().getTime()) / (1000 * 60 * 60 * 24); System.out.println("überfällige Tagen: " + overdueTage); double gebuehr = rechneOverdueGebuehren(overdueTage); ausleiher.addiereZuOffeneGebuehren(gebuehr); - System.out.println("Überfällige Gebühren für " + ausleiher.getName() + gebuehr + " Eur."); + System.out.println("Medium '" + medium.getTitel() + "' wurde erfolgreich zurückgegeben."); + System.out.println("Überfällige Gebühren für " + ausleiher.getName() + ": " + gebuehr + " Eur."); }else { - System.out.println("Keine überfällige Gebühren."); + System.out.println("Medium '" + medium.getTitel()+ "' wurde rechtzeitig zurückgegeben"); } + System.out.println("Verbleibende ausgeliehene Medien von " + ausleiher.getName() + ":"); ausleiher.anzeigenAusleihen(); - } catch (Exception e) { - System.out.println(e.getMessage()); - } + } //Methode zum Anzeigen des Gebührenkontos @@ -179,7 +180,13 @@ public class BibliothekSystem { Medium medium = findeMedium(mediumID); if (benutzer != null && medium != null && medium.istAusgeliehen()) { if (medium.istVerlaengerbar()) { - medium.verlaengern(); + if (medium.istVerlaengerbar()) { + medium.verlaengerungen--; + setzeAktuellesDatumZurueck(); + medium.setRueckgabedatum(medium.rechneRueckgabedatum(aktuellesDatum)); + } else{ + System.out.println("Keine Verlängerung mehr möglich."); + } System.out.println("Leihfrist für '" + medium.getTitel() + "' verlängert."); System.out.println("Neues Rückgabedatum: " + medium.getRueckgabedatum()); System.out.println("Weitere Verlängerungen möglich: " + medium.getVerlaengerungen()); @@ -198,6 +205,7 @@ public class BibliothekSystem { } //Methode zum Finden eines Mediums + //Von AI generiert public Medium findeMedium(String ID) { return medienListe.stream() .filter(m -> m.getID().equals(ID)) @@ -207,8 +215,8 @@ public class BibliothekSystem { //Methode, um das Systemdatum zu setzen - public void setAktuellesDatum(Date neuesDatum) { - this.aktuellesDatum = neuesDatum; + public void setAktuellesDatum(Date manuellesDatum) { + this.aktuellesDatum = manuellesDatum; System.out.println("Systemdatum geändert auf: " + aktuellesDatum); } @@ -216,9 +224,14 @@ public class BibliothekSystem { return aktuellesDatum; } + public void setzeAktuellesDatumZurueck(){ + this.aktuellesDatum = new Date(); + } + public void benutzerRegistrieren(Benutzer benutzer) { benutzerListe.add(benutzer); - System.out.println("Benutzer registriert: " + benutzer); + double jahresgebuehr = benutzer.getJahresgebuehr(); + System.out.println("Benutzer registriert: " + benutzer + ", Jahresgebühr: " + jahresgebuehr); } /*public void zeigeGebuehren(Benutzer benutzer) { @@ -231,6 +244,10 @@ public class BibliothekSystem { } }*/ + + + //Methode zum Berechnen der overdue-Gebühren + //Von AI generiert public double rechneOverdueGebuehren(long overdueTagen) { if (overdueTagen <= 0){ return 0;