3012375
/
SE2-Restaurantverwaltung
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Funktionierender Merge von Finanzverwaltung und Reservierungsverwaltung

master
PC 2025-01-11 18:34:58 +01:00
parent 953529616c
commit e47c05ecd8
8 changed files with 333 additions and 307 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

157
Restaurantverwaltung/src/Bestellsystem.java
View File

@ -24,80 +24,107 @@ public class Bestellsystem {
System.out.print("Bitte gib die Tischnummer ein: "); System.out.print("Bitte gib die Tischnummer ein: ");
String tischNummer = scanner.nextLine(); String tischNummer = scanner.nextLine();
Bestellung bestellung = new Bestellung(tischNummer); Bestellung bestellung = new Bestellung(tischNummer);
while (true) { while (true) {
// Gericht auswählen // List<Dish> Gerichte = new ArrayList<>(menu.getDishes());
System.out.print("Bitte bestelle ein Gericht (oder 'fertig', um abzuschließen): "); // try (BufferedReader reader = new BufferedReader(new FileReader(STOCK_FILE))) {
String gericht = scanner.nextLine(); // String line;
boolean istVerfuegbar = false; // while ((line = reader.readLine()) != null) {
// String[] parts = line.split(",");
// Wenn der Benutzer 'fertig' eingibt, wird die Bestellung gespeichert //
if (gericht.equalsIgnoreCase("fertig")) { // String name = parts[0];
speichereBestellung(bestellung); // Integer count = Integer.parseInt(parts[1]);
System.out.println("Bestand wurde aktualisiert"); // stock.put(name, count);
break; //
} // }
// } catch (FileNotFoundException e) {
// Überprüfen, ob das Gericht im Menü verfügbar ist // System.out.println("Stockdatenbank nicht gefunden. Einträge müssen manuell erstellt werden");
try { //
for (Dish dish : menu.getDishes()) { // } catch (IOException e) {
if (gericht.equalsIgnoreCase(dish.getName())) { // System.out.println("Fehler beim Lesen der Benutzerdatenbank: " + e.getMessage());
// Zutaten für das Gericht verwenden (Bestand aktualisieren) // }
SystemController.inventory.useIngredients(dish.getIngredients()); // for (Dish gericht : Gerichte) {
bestellung.addGericht(gericht); // Gericht zur Bestellung hinzufügen // if (stock.containsKey(gericht.getName())) {
istVerfuegbar = true; // if (stock.get(gericht.getName()) < )
bestellungen.add(bestellung); // Bestellung zur Liste der Bestellungen hinzufügen // }
System.out.println("Bestellung wurde aktualisiert"); // }
System.out.println(bestellung.getBestellungDetails()); // Bestellungsdetails anzeigen System.out.print("Bitte bestelle ein Gericht (oder 'fertig', um abzuschließen): ");
break; String gericht = scanner.nextLine();
} boolean istVerfuegbar = false;
} if (gericht.equalsIgnoreCase("fertig")) {
} catch (Exception e) { speichereBestellung(bestellung);
System.out.println("Fehler beim Hinzufügen des Gerichts zur Bestellung: " + e.getMessage()); System.out.println("Bestand wurde aktualisiert");
}
// Wenn das Gericht nicht im Menü ist, eine Fehlermeldung anzeigen
if (!istVerfuegbar) {
System.out.println("Gericht ist nicht im Menü.");
}
}
}
public static void loescheBestellung() {
ladeUndZeigeBestellungen();
System.out.print("Gib die ID der zu löschenden Bestellung ein: ");
String id = scanner.nextLine();
Bestellung zuLoeschen = null;
for (Bestellung bestellung : bestellungen) {
if (bestellung.getId().equals(id)) {
zuLoeschen = bestellung;
break; break;
} }
} try { for (Dish dish : menu.getDishes()) {
if (gericht.equalsIgnoreCase(dish.getName())) {
SystemController.inventory.useIngredients(dish.getIngredients());
bestellung.addGericht(gericht);
istVerfuegbar = true;
bestellungen.add(bestellung);
System.out.println("Bestellung wurde aktualisiert");
System.out.println(bestellung.getBestellungDetails());
if (zuLoeschen != null) { }
bestellungen.remove(zuLoeschen); // else {
aktualisiereDatei(); // System.out.println("Ist nicht verfügbar");
System.out.println("Bestellung wurde gelöscht."); // }
} else { }} catch (Exception e ) {
System.out.println("Keine Bestellung mit der angegebenen ID gefunden.");
}
}
private static void aktualisiereDatei() {
try (FileWriter writer = new FileWriter(FILE_PATH, false)) {
for (Bestellung bestellung : bestellungen) {
writer.write(bestellung.toFileFormat());
} }
} catch (IOException e) { if (istVerfuegbar == false) {
System.out.println("Fehler beim Aktualisieren der Datei: " + e.getMessage()); System.out.println("Gericht ist nicht im Menu");
}
// while (true) {
// System.out.print("Möchte der Kunde noch einen Zusatzwunsch für dieses Gericht? (ja/nein): ");
// String wunschAntwort = scanner.nextLine();
//
// if (wunschAntwort.equalsIgnoreCase("ja")) {
// System.out.print("Bitte gib den Zusatzwunsch ein (z.B. 'keine Tomaten'): ");
// String zusatzWunsch = scanner.nextLine();
// bestellung.addZusatzWunsch(zusatzWunsch);
// } else if (wunschAntwort.equalsIgnoreCase("nein")) {
// break;
// }
// }
} }
} }
public static void loescheBestellung() {
ladeUndZeigeBestellungen();
System.out.print("Gib die ID der zu löschenden Bestellung ein: ");
String id = scanner.nextLine();
Bestellung zuLoeschen = null;
for (Bestellung bestellung : bestellungen) {
if (bestellung.getId().equals(id)) {
zuLoeschen = bestellung;
break;
}
}
if (zuLoeschen != null) {
bestellungen.remove(zuLoeschen);
aktualisiereDatei();
System.out.println("Bestellung wurde gelöscht.");
} else {
System.out.println("Keine Bestellung mit der angegebenen ID gefunden.");
}
}
private static void aktualisiereDatei() {
try (FileWriter writer = new FileWriter(FILE_PATH, false)) {
for (Bestellung bestellung : bestellungen) {
writer.write(bestellung.toFileFormat());
}
} catch (IOException e) {
System.out.println("Fehler beim Aktualisieren der Datei: " + e.getMessage());
}
}
public static void speichereBestellung(Bestellung bestellung) { public static void speichereBestellung(Bestellung bestellung) {
try { try {

34
Restaurantverwaltung/src/Bestellungen.txt
View File

@ -12,37 +12,3 @@ Bestellte Gerichte:
Zeit: 16:13 Zeit: 16:13
-------------------------- --------------------------
ID: 657b07cf-3416-43a6-9477-8f057541caeb
Tisch Nummer: 01
Bestellte Gerichte:
Zeit: 17:13
--------------------------
ID: 13b6908f-6b5e-4ed5-9d83-a01913bf0608
Tisch Nummer: Ramen
Bestellte Gerichte:
Zeit: 17:25
--------------------------
ID: dbe203a2-da99-4420-8095-999f79d37eaa
Tisch Nummer: Cheeseburger
Bestellte Gerichte:
Zeit: 17:28
--------------------------
ID: f72aa0bf-d739-4e72-9654-add74abc3cea
Tisch Nummer: 01
Bestellte Gerichte:
- Cheeseburger
- Ramen
- Ramen
Zeit: 17:33
--------------------------
ID: 8adf6247-e041-46fd-86ee-2773b2eb69fe
Tisch Nummer: 01
Bestellte Gerichte:
- Cheeseburger
Zeit: 17:42
--------------------------

11
Restaurantverwaltung/src/Dish.java
View File

@ -1,14 +1,11 @@
import java.util.Map; import java.util.*;
class Dish { class Dish {
private String name; private String name;
private Map<String, Integer> ingredients; private Map<String, Integer> ingredients;
private double price; // Preis für jedes Gericht
public Dish(String name, Map<String, Integer> ingredients, double price) { public Dish(String name, Map<String, Integer> ingredients) {
this.name = name; this.name = name;
this.ingredients = ingredients; this.ingredients = ingredients;
this.price = price;
} }
public String getName() { public String getName() {
@ -18,8 +15,4 @@ class Dish {
public Map<String, Integer> getIngredients() { public Map<String, Integer> getIngredients() {
return ingredients; return ingredients;
} }
public double getPrice() {
return price;
}
} }

200
Restaurantverwaltung/src/FinancialManager.java
View File

@ -1,92 +1,144 @@
import java.time.LocalDate; import java.io.*;
import java.util.HashMap; import java.text.SimpleDateFormat;
import java.util.Map; import java.util.*;
public class FinancialManager { class FinancialManager {
private double totalRevenue; private static final String TRANSACTION_FILE = "src/transactions.txt"; // Datei für Transaktionen (Einnahmen und Ausgaben)
private double totalExpenses; private List<Transaction> transactions = new ArrayList<>();
private double totalProfit;
private Map<LocalDate, Double> dailyRevenue = new HashMap<>();
private Map<LocalDate, Double> weeklyRevenue = new HashMap<>();
private Map<LocalDate, Double> monthlyRevenue = new HashMap<>();
private Map<LocalDate, Double> dailyExpenses = new HashMap<>();
private Map<LocalDate, Double> weeklyExpenses = new HashMap<>();
private Map<LocalDate, Double> monthlyExpenses = new HashMap<>();
// Methode zur Hinzufügung von Einnahmen public FinancialManager() {
public void addRevenue(double amount) { loadTransactionsFromFile();
this.totalRevenue += amount;
LocalDate today = LocalDate.now();
dailyRevenue.put(today, dailyRevenue.getOrDefault(today, 0.0) + amount);
// Einnahmen für die Woche und den Monat aktualisieren
LocalDate startOfWeek = today.minusDays(today.getDayOfWeek().getValue() - 1);
weeklyRevenue.put(startOfWeek, weeklyRevenue.getOrDefault(startOfWeek, 0.0) + amount);
LocalDate startOfMonth = today.withDayOfMonth(1);
monthlyRevenue.put(startOfMonth, monthlyRevenue.getOrDefault(startOfMonth, 0.0) + amount);
} }
// Methode zur Hinzufügung von Ausgaben public void recordTransaction(double amount, String description, boolean isIncome) {
public void addExpense(double amount) { Date date = new Date();
this.totalExpenses += amount; Transaction transaction = new Transaction(amount, description, isIncome, date);
LocalDate today = LocalDate.now(); transactions.add(transaction);
dailyExpenses.put(today, dailyExpenses.getOrDefault(today, 0.0) + amount); saveTransactionToFile(transaction);
// Ausgaben für die Woche und den Monat aktualisieren
LocalDate startOfWeek = today.minusDays(today.getDayOfWeek().getValue() - 1);
weeklyExpenses.put(startOfWeek, weeklyExpenses.getOrDefault(startOfWeek, 0.0) + amount);
LocalDate startOfMonth = today.withDayOfMonth(1);
monthlyExpenses.put(startOfMonth, monthlyExpenses.getOrDefault(startOfMonth, 0.0) + amount);
} }
// Methode zur Berechnung der Einnahmen für einen bestimmten Zeitraum private void saveTransactionToFile(Transaction transaction) {
public double getRevenueForPeriod(String period) { try (BufferedWriter writer = new BufferedWriter(new FileWriter(TRANSACTION_FILE, true))) {
LocalDate today = LocalDate.now(); SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
switch (period.toLowerCase()) { String transactionLine = dateFormat.format(transaction.getDate()) + ";" + transaction.getAmount() + ";" + transaction.getDescription() + ";" + (transaction.isIncome() ? "Income" : "Expense");
case "daily": writer.write(transactionLine);
return dailyRevenue.getOrDefault(today, 0.0); writer.newLine();
case "weekly": } catch (IOException e) {
LocalDate startOfWeek = today.minusDays(today.getDayOfWeek().getValue() - 1); System.out.println("Fehler beim Speichern der Transaktion: " + e.getMessage());
return weeklyRevenue.getOrDefault(startOfWeek, 0.0);
case "monthly":
LocalDate startOfMonth = today.withDayOfMonth(1);
return monthlyRevenue.getOrDefault(startOfMonth, 0.0);
default:
return 0.0;
} }
} }
// Methode zur Berechnung der Ausgaben für einen bestimmten Zeitraum private void loadTransactionsFromFile() {
public double getExpensesForPeriod(String period) { try (BufferedReader reader = new BufferedReader(new FileReader(TRANSACTION_FILE))) {
LocalDate today = LocalDate.now(); String line;
switch (period.toLowerCase()) { while ((line = reader.readLine()) != null) {
case "daily": String[] parts = line.split(";");
return dailyExpenses.getOrDefault(today, 0.0); SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
case "weekly": Date date = dateFormat.parse(parts[0]);
LocalDate startOfWeek = today.minusDays(today.getDayOfWeek().getValue() - 1); double amount = Double.parseDouble(parts[1]);
return weeklyExpenses.getOrDefault(startOfWeek, 0.0); String description = parts[2];
case "monthly": boolean isIncome = "Income".equals(parts[3]);
LocalDate startOfMonth = today.withDayOfMonth(1); transactions.add(new Transaction(amount, description, isIncome, date));
return monthlyExpenses.getOrDefault(startOfMonth, 0.0); }
default: } catch (IOException | java.text.ParseException e) {
return 0.0; System.out.println("Fehler beim Laden der Transaktionen: " + e.getMessage());
} }
} }
// Getter für Gesamtumsatz public void showFinancialReport(String period) {
public double getTotalRevenue() { double totalIncome = 0;
return totalRevenue; double totalExpense = 0;
Date startDate = null;
Date endDate = new Date();
switch (period.toLowerCase()) {
case "daily":
startDate = getStartOfDay();
break;
case "weekly":
startDate = getStartOfWeek();
break;
case "monthly":
startDate = getStartOfMonth();
break;
default:
System.out.println("Ungültige Zeitraumoption!");
return;
}
// Berechnen der Einnahmen und Ausgaben im angegebenen Zeitraum
for (Transaction transaction : transactions) {
if (!transaction.getDate().before(startDate) && !transaction.getDate().after(endDate)) {
if (transaction.isIncome()) {
totalIncome += transaction.getAmount();
} else {
totalExpense += transaction.getAmount();
}
}
}
System.out.println("\n--- Finanzbericht für " + period + " ---");
System.out.println("Gesamte Einnahmen: " + totalIncome + " EUR");
System.out.println("Gesamte Ausgaben: " + totalExpense + " EUR");
System.out.println("Nettogewinn: " + (totalIncome - totalExpense) + " EUR");
} }
// Getter für Gesamtausgaben private Date getStartOfDay() {
public double getTotalExpenses() { Calendar cal = Calendar.getInstance();
return totalExpenses; cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return cal.getTime();
} }
// Berechnung des Nettogewinns private Date getStartOfWeek() {
public double getNetProfit() { Calendar cal = Calendar.getInstance();
return totalRevenue - totalExpenses; cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return cal.getTime();
}
private Date getStartOfMonth() {
Calendar cal = Calendar.getInstance();
cal.set(Calendar.DAY_OF_MONTH, 1);
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);
return cal.getTime();
}
}
class Transaction {
private double amount;
private String description;
private boolean isIncome;
private Date date;
public Transaction(double amount, String description, boolean isIncome, Date date) {
this.amount = amount;
this.description = description;
this.isIncome = isIncome;
this.date = date;
}
public double getAmount() {
return amount;
}
public String getDescription() {
return description;
}
public boolean isIncome() {
return isIncome;
}
public Date getDate() {
return date;
} }
} }

188
Restaurantverwaltung/src/Inventory.java
View File

@ -1,141 +1,129 @@
import java.io.*;
import java.util.*; import java.util.*;
import java.io.*;
public class Inventory { class Inventory {
private Map<String, Integer> stock;
private final String STOCK_FILE = "src/stock.txt";
private Map<String, Integer> stock = new HashMap<>();
private FinancialManager financialManager; // Deklaration der Instanzvariable
public Inventory(FinancialManager financialManager) {
this.financialManager = financialManager; // Initialisierung des FinancialManagers im Konstruktor
}
private final String STOCK_FILE = "src/stock.txt"; // Datei für den Bestand
// Lädt den Bestand aus der Datei
public void loadStockFromFile() { public void loadStockFromFile() {
stock.clear(); stock = new HashMap<>();
try (BufferedReader reader = new BufferedReader(new FileReader(STOCK_FILE))) { try (BufferedReader reader = new BufferedReader(new FileReader(STOCK_FILE))) {
String line; String line;
while ((line = reader.readLine()) != null) { while ((line = reader.readLine()) != null) {
String[] parts = line.split(":"); String[] parts = line.split(",");
if (parts.length == 2) {
String ingredientName = parts[0]; String name = parts[0];
int quantity = Integer.parseInt(parts[1]); Integer count = Integer.parseInt(parts[1]);
stock.put(ingredientName, quantity); stock.put(name, count);
}
} }
} catch (FileNotFoundException e) { } catch (FileNotFoundException e) {
System.out.println("Bestand-Datei nicht gefunden, neue Datei wird erstellt."); System.out.println("Stockdatenbank nicht gefunden. Einträge müssen manuell erstellt werden");
} catch (IOException e) { } catch (IOException e) {
System.out.println("Fehler beim Laden des Bestands: " + e.getMessage()); System.out.println("Fehler beim Lesen der Benutzerdatenbank: " + e.getMessage());
} }
} }
// Speichert den aktuellen Bestand in die Datei
public void saveStockToFile() { public void saveStockToFile() {
try (BufferedWriter writer = new BufferedWriter(new FileWriter(STOCK_FILE))) { try (BufferedWriter writer = new BufferedWriter(new FileWriter(STOCK_FILE))) {
for (Map.Entry<String, Integer> entry : stock.entrySet()) { for (Map.Entry<String, Integer> entry : stock.entrySet()) {
writer.write(entry.getKey() + ":" + entry.getValue()); writer.write(entry.getKey() + "," + entry.getValue());
writer.newLine(); writer.newLine();
} }
} catch (IOException e) { } catch (IOException e) {
System.out.println("Fehler beim Speichern des Bestands: " + e.getMessage()); System.out.println("Fehler beim Speichern der Datei: " + e.getMessage());
} }
} }
// Zeigt den aktuellen Bestand an public Inventory() {
}
public void viewStock() { public void viewStock() {
if (stock.isEmpty()) { System.out.println("Aktueller Bestand:");
System.out.println("Der Bestand ist leer."); for (Map.Entry<String, Integer> entry : stock.entrySet()) {
} else { System.out.println(entry.getKey() + ": " + entry.getValue());
System.out.println("\n--- Aktueller Bestand ---");
for (Map.Entry<String, Integer> entry : stock.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue() + " Stück");
}
} }
} }
// Bestellmenge verringern (z.B. beim Bestellen)
public void useIngredients(Map<String, Integer> usedIngredients) {
for (Map.Entry<String, Integer> entry : usedIngredients.entrySet()) {
String ingredientName = entry.getKey();
int amountUsed = entry.getValue();
if (stock.containsKey(ingredientName)) {
int currentStock = stock.get(ingredientName);
if (currentStock >= amountUsed) {
stock.put(ingredientName, currentStock - amountUsed);
} else {
System.out.println("Nicht genügend Bestand für " + ingredientName);
}
} else {
System.out.println("Zutat " + ingredientName + " existiert nicht im Bestand.");
}
}
}
// Bestand erweitern und berechnen, ob Ausgaben hinzuzufügen sind
public void addIngredients(String productName, int amountToAdd, FinancialManager financialManager) {
double ingredientCost = 1.0; // Beispielhafter Preis für Zutaten (z.B. 1 Euro pro Stück)
// Addiere die Zutaten zum Bestand
stock.put(productName, stock.getOrDefault(productName, 0) + amountToAdd);
// Berechne die Ausgaben für die Erweiterung des Bestands
double totalCost = ingredientCost * amountToAdd;
// Gebe die Kosten in den Finanzen an
financialManager.addExpense(totalCost);
System.out.println("Bestand für " + productName + " wurde um " + amountToAdd + " Stück erhöht.");
}
// Gibt den Preis für eine bestimmte Zutat zurück (Beispielpreise)
private double getPriceForIngredient(String ingredientName) {
switch (ingredientName.toLowerCase()) {
case "salat":
return 1.5; // Preis für Salat pro Einheit
case "tomaten":
return 0.8; // Preis für Tomaten pro Einheit
case "cheeseburger":
return 3.0; // Preis für Cheeseburger pro Einheit
default:
return 1.0; // Standardpreis pro Einheit
}
}
// In der Inventory-Klasse:
public boolean showIngredientsAvailable(Map<String, Integer> ingredients) { public boolean showIngredientsAvailable(Map<String, Integer> ingredients) {
for (Map.Entry<String, Integer> entry : ingredients.entrySet()) { for (Map.Entry<String, Integer> entry : ingredients.entrySet()) {
String ingredient = entry.getKey(); String ingredient = entry.getKey();
int requiredAmount = entry.getValue(); int amount = entry.getValue();
// Überprüfe, ob der Lagerbestand ausreicht if (!stock.containsKey(ingredient) || stock.get(ingredient) < amount) {
if (!stock.containsKey(ingredient) || stock.get(ingredient) < requiredAmount) { return false;
System.out.println("Nicht genügend Bestand für: " + ingredient); // Fehlermeldung }
return false; }
}
} return true;
return true;
} }
public void useIngredients(Map<String, Integer> ingredients) {
public void overwriteStock(String productName, int newAmount) { for (Map.Entry<String, Integer> entry : ingredients.entrySet()) {
if (stock.containsKey(productName)) { stock.put(entry.getKey(), stock.get(entry.getKey()) - entry.getValue());
stock.put(productName, newAmount); saveStockToFile();
System.out.println("Der Bestand für " + productName + " wurde auf " + newAmount + " Stück geändert."); }
}
// Neue Methode: Zutaten hinzufügen
public void addIngredients(String ingredient, int amount) {
if (amount <= 0) {
System.out.println("Ungültige Menge: " + amount);
return;
}
stock.put(ingredient, stock.getOrDefault(ingredient, 0) + amount);
System.out.println(amount + " " + ingredient + " hinzugefügt.");
}
// Neue Methode: Zutaten entfernen
public void removeIngredient(String ingredient) {
if (stock.containsKey(ingredient)) {
stock.remove(ingredient);
System.out.println(ingredient + " wurde aus dem Lager entfernt.");
} else { } else {
System.out.println("Das Produkt " + productName + " existiert nicht im Bestand."); System.out.println(ingredient + " ist nicht im Lager vorhanden.");
} }
} }
// Getter für den Bestand // Neue Methode: Gesamten Bestand prüfen
public Map<String, Integer> getStock() { public int totalStock() {
return stock; int total = 0;
for (int amount : stock.values()) {
total += amount;
}
return total;
} }
// Setter für den Bestand // Neue Methode: Warnungen bei niedrigem Bestand
public void setStock(Map<String, Integer> stock) { public void lowStockWarning(int threshold) {
this.stock = stock; System.out.println("Warnung: Niedriger Bestand bei folgenden Zutaten:");
for (Map.Entry<String, Integer> entry : stock.entrySet()) {
if (entry.getValue() < threshold) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}
}
}
// Neue Methode: Zutatenbestand überschreiben
public void overwriteStock(String ingredient, int amount) {
if (amount < 0) {
System.out.println("Ungültige Menge: " + amount);
return;
}
if (stock.containsKey(ingredient)) {
stock.put(ingredient, amount);
System.out.println(ingredient + " Bestand auf " + amount + " gesetzt.");
} else {
System.out.println(ingredient + " ist nicht im Lager vorhanden. Hinzufügen mit neuer Menge.");
stock.put(ingredient, amount);
}
} }
} }

19
Restaurantverwaltung/src/Menu.java
View File

@ -1,17 +1,16 @@
import java.util.*; import java.util.*;
public class Menu { class Menu {
public List<Dish> dishes = new ArrayList<>(); public List<Dish> dishes = new ArrayList<>();
public List<Dish> availableDishes = new ArrayList<>(); public List<Dish> availableDishes = new ArrayList<>();
public Menu() { public Menu() {
dishes.add(new Dish("Cheeseburger", Map.of("Brot", 1, "Fleisch", 1, "Käse", 1), 5.0));
dishes.add(new Dish("Veggie-Burger", Map.of("Brot", 1, "Salat", 1, "Tomaten", 1), 4.0));
dishes.add(new Dish("Double Meat Burger", Map.of("Brot", 1, "Fleisch", 2), 6.0));
dishes.add(new Dish("Ramen", Map.of("Soße", 1, "Salat", 1, "Tomaten", 1, "Nudeln", 30), 7.0));
}
dishes.add(new Dish("Cheeseburger", Map.of("Brot", 1, "Fleisch", 1, "Käse", 1)));
dishes.add(new Dish("Veggie-Burger", Map.of("Brot", 1, "Salat", 1, "Tomaten", 1)));
dishes.add(new Dish("Double Meat Burger", Map.of("Brot", 1, "Fleisch", 2)));
dishes.add(new Dish("Ramen", Map.of("Soße", 1, "Salat", 1, "Tomaten", 1, "Nudeln", 30)));
}
public void displayMenu(Inventory inventory) { public void displayMenu(Inventory inventory) {
System.out.println("Verfügbares Menü:"); System.out.println("Verfügbares Menü:");

2
Restaurantverwaltung/src/SystemController.java
View File

@ -272,4 +272,4 @@ class SystemController {
default -> System.out.println("Ungültige Auswahl."); default -> System.out.println("Ungültige Auswahl.");
} }
} }
**/} }

15
Restaurantverwaltung/src/stock.txt
View File

@ -1,7 +1,8 @@
Tomaten:100 01,100
Salat:260 Soße,49999996
Käse:100 Ananasdasdas,5000
Brot:100 Brot,1503
Soße:100 Tomaten,503
Fleisch:200 Käse,715
Nudeln:150 Fleisch,93
Salat,494