ausgabe korrigiert

README.md

@@ -1,2 +1,9 @@
 # TravelBuddyApp 
+( Caroline Ufer und Bohdana Illiuk )
 
+Login-Namen:
+1. max, 12345
+2. lisa, 1111
+3. anna, pass123
+4. mike, 54321
+5. sven, 112233

TravelBuddyApp/.classpath

@@ -36,5 +36,6 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
+	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
 	<classpathentry kind="output" path="target/classes"/>
 </classpath>

TravelBuddyApp/dependency-reduced-pom.xml

@@ -0,0 +1,144 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>hs-mannheim.de</groupId>
+  <artifactId>TravelBuddyApp</artifactId>
+  <version>0.0.1-SNAPSHOT</version>
+  <build>
+    <plugins>
+      <plugin>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.8.1</version>
+        <configuration>
+          <source>${maven.compiler.source}</source>
+          <target>${maven.compiler.target}</target>
+        </configuration>
+      </plugin>
+      <plugin>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.2.4</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <transformers>
+                <transformer>
+                  <mainClass>de.hs_mannheim.informatik.mvn.Main</mainClass>
+                </transformer>
+              </transformers>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.jacoco</groupId>
+        <artifactId>jacoco-maven-plugin</artifactId>
+        <version>0.8.12</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>prepare-agent</goal>
+            </goals>
+          </execution>
+          <execution>
+            <id>report</id>
+            <phase>test</phase>
+            <goals>
+              <goal>report</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <artifactId>maven-pmd-plugin</artifactId>
+        <version>3.22.0</version>
+        <executions>
+          <execution>
+            <phase>verify</phase>
+            <goals>
+              <goal>check</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.owasp</groupId>
+        <artifactId>dependency-check-maven</artifactId>
+        <version>9.2.0</version>
+        <executions>
+          <execution>
+            <goals>
+              <goal>check</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.13.1</version>
+      <scope>test</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>hamcrest-core</artifactId>
+          <groupId>org.hamcrest</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-engine</artifactId>
+      <version>5.9.3</version>
+      <scope>test</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>junit-platform-engine</artifactId>
+          <groupId>org.junit.platform</groupId>
+        </exclusion>
+        <exclusion>
+          <artifactId>apiguardian-api</artifactId>
+          <groupId>org.apiguardian</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.jupiter</groupId>
+      <artifactId>junit-jupiter-api</artifactId>
+      <version>5.9.3</version>
+      <scope>test</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>opentest4j</artifactId>
+          <groupId>org.opentest4j</groupId>
+        </exclusion>
+        <exclusion>
+          <artifactId>apiguardian-api</artifactId>
+          <groupId>org.apiguardian</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>org.junit.platform</groupId>
+      <artifactId>junit-platform-commons</artifactId>
+      <version>1.9.3</version>
+      <scope>test</scope>
+      <exclusions>
+        <exclusion>
+          <artifactId>apiguardian-api</artifactId>
+          <groupId>org.apiguardian</groupId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+  </dependencies>
+  <properties>
+    <maven.compiler.target>21</maven.compiler.target>
+    <maven.compiler.source>21</maven.compiler.source>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+</project>

TravelBuddyApp/pom.xml

@@ -13,15 +13,38 @@
 	</properties>
 	<dependencies>
 		<dependency>
-			<groupId>org.junit.jupiter</groupId>
-			<artifactId>junit-jupiter-api</artifactId>
-			<version>5.8.1</version>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>4.13.1</version>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+			<groupId>org.json</groupId>
+			<artifactId>json</artifactId>
+			<version>20210307</version>
+		</dependency>
+		<dependency>
+			<groupId>commons-codec</groupId>
+			<artifactId>commons-codec</artifactId>
+			<version>1.15</version>
+		</dependency>
 		<dependency>
 			<groupId>org.junit.jupiter</groupId>
 			<artifactId>junit-jupiter-engine</artifactId>
-			<version>5.8.1</version>
+			<version>5.9.3</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>org.junit.jupiter</groupId>
+			<artifactId>junit-jupiter-api</artifactId>
+			<version>5.9.3</version>
+			<scope>test</scope>
+		</dependency>
+		<!-- JUnit Platform Commons -->
+		<dependency>
+			<groupId>org.junit.platform</groupId>
+			<artifactId>junit-platform-commons</artifactId>
+			<version>1.9.3</version>
 			<scope>test</scope>
 		</dependency>
 	</dependencies>
@@ -52,7 +75,7 @@
 								<transformer
 									implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
 									<mainClass>
-										de.hs_mannheim.informatik.mvn.Main</mainClass>
+										ui.UserInterface</mainClass>
 								</transformer>
 							</transformers>
 						</configuration>
@@ -84,6 +107,7 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-pmd-plugin</artifactId>
 				<version>3.22.0</version>
+
 				<executions>
 					<execution>
 						<phase>verify</phase>

TravelBuddyApp/src/main/java/domain/Auto.java

@@ -3,13 +3,29 @@ package domain;
 public class Auto {
 
 	private String name;
-    private double co2AusstossProKm;
+	private double co2AusstossProKm;
 
 
-    public Auto(String name, double co2AusstossProKm) {
-        this.name = name;
-        this.co2AusstossProKm = co2AusstossProKm;
-    }
+	public Auto(String name, double co2AusstossProKm) {
 		
+		this.name = name;
+		this.co2AusstossProKm = co2AusstossProKm;
+	}
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(String name) {
+		this.name = name;
+	}
+
+	public double getCO2AusstossProKm() {
+		return co2AusstossProKm;
+	}
+
+	public void setCO2AusstossProKm(double co2AusstossProKm) {
+		this.co2AusstossProKm = co2AusstossProKm;
+	}
 
 }

TravelBuddyApp/src/main/java/domain/KurztripEmpfehlung.java

@@ -1,5 +1,138 @@
 package domain;
 
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+
 public class KurztripEmpfehlung {
 
+	private List<Ort> alleOrte;
+	private Ort heimatort;
+
+	public KurztripEmpfehlung() {
+		this.alleOrte = ladeAlleOrte();
+		this.heimatort = null;
+	}
+
+	public void setHeimatort(Ort heimatort) {
+		this.heimatort = heimatort;
+	}
+	
+	
+
+	public List<Ort> zufallsorteFahrrad(int maxEntfernung) {
+		List<Ort> gefilterteOrte = new ArrayList<>();
+
+		if (heimatort == null) {
+			System.out.println("Heimatort ist nicht gesetzt.");
+			return gefilterteOrte;
+		}
+
+		for (Ort ort : alleOrte) {
+			double entfernung = berechneEntfernung(heimatort, ort);
+			if (entfernung <= maxEntfernung) {
+				gefilterteOrte.add(ort);
+			}
+		}
+
+		if (gefilterteOrte.isEmpty()) {
+			System.out.println("Keine Orte innerhalb der Entfernung von " + maxEntfernung + " km gefunden.");
+			return gefilterteOrte;
+		}
+
+		return zufallsorteAuswaehlen(gefilterteOrte, 3);
+	}
+
+	
+	
+	public List<Ort> zufallsortePKW(int minEntfernung) {
+		List<Ort> gefilterteOrte = new ArrayList<>();
+
+		if (heimatort == null) {
+			System.out.println("Heimatort ist nicht gesetzt.");
+			return gefilterteOrte;
+		}
+
+		for (Ort ort : alleOrte) {
+			double entfernung = berechneEntfernung(heimatort, ort);
+			if (entfernung >= minEntfernung) {
+				gefilterteOrte.add(ort);
+			}
+		}
+
+		if (gefilterteOrte.isEmpty()) {
+			System.out.println("Keine Orte mindestens " + minEntfernung + " km entfernt gefunden.");
+			return gefilterteOrte;
+		}
+
+		return zufallsorteAuswaehlen(gefilterteOrte, 3);
+	}
+
+	private List<Ort> zufallsorteAuswaehlen(List<Ort> orte, int anzahl) {
+		List<Ort> zufallsorte = new ArrayList<>();
+		Random random = new Random();
+
+		int size = orte.size();
+		if (size <= 0) {
+			throw new IllegalArgumentException("Die Liste der Orte ist leer oder hat eine ungültige Größe.");
+		}
+
+		for (int i = 0; i < anzahl; i++) {
+			int index = random.nextInt(size);
+			zufallsorte.add(orte.get(index));
+			orte.remove(index); // Sicherstellen, dass Orte nicht doppelt empfohlen werden
+			size--; // Reduzieren der Größe der Liste nach Entfernen eines Elements
+		}
+
+		return zufallsorte;
+	}
+
+	public double berechneEntfernung(Ort standort, Ort zielort) {
+
+		double b1 = Math.toRadians(standort.getBreitengrad());
+		double b2 = Math.toRadians(zielort.getBreitengrad());
+		double l1 = Math.toRadians(standort.getLängengrad());
+		double l2 = Math.toRadians(zielort.getLängengrad());
+
+		double entfernung = (6378.388
+				* Math.acos(Math.sin(b1) * Math.sin(b2) + Math.cos(b1) * Math.cos(b2) * Math.cos(l2 - l1))) * 1.25;
+
+		return entfernung;
+	}
+		
+	
+	
+	private List<Ort> ladeAlleOrte() {
+		List<Ort> alleOrte = new ArrayList<>();
+
+		String csvFile = "src/main/resources/PLZ.csv";
+		String line;
+		try (BufferedReader br = new BufferedReader(new FileReader(csvFile))) {
+			while ((line = br.readLine()) != null) {
+				line = line.replaceAll("\\s+", "");
+				String[] data = line.split(";");
+				int plz = Integer.parseInt(data[0].replaceAll("\"", ""));
+				String ortName = data[1].replaceAll("\"", "");
+				double breitengrad = Double.parseDouble(data[2].replaceAll("\"", ""));
+				double laengengrad = Double.parseDouble(data[3].replaceAll("\"", ""));
+				Ort ort = new Ort(plz, ortName, breitengrad, laengengrad);
+				alleOrte.add(ort);
+			}
+		} catch (IOException e) {
+			System.err.println("Fehler beim Lesen der Datei: " + e.getMessage());
+			e.printStackTrace();
+		} catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
+			System.err.println("Fehlerhaftes Datenformat in der CSV-Datei: " + e.getMessage());
+			e.printStackTrace();
+		}
+
+		return alleOrte;
+	}
+
+	public Object getHeimatort() {
+		return heimatort;
+	}
 }

TravelBuddyApp/src/main/java/domain/Ort.java

@@ -1,26 +1,47 @@
 package domain;
 
-import java.util.Set;
+import java.io.IOException;
+
 
 public class Ort {
 
 	private int plz;
 	private String name;
-	private double breitengrad;
-	private double längengrad;
+	public double breitengrad;
+	public double längengrad;
 	
-	
-	public Ort(int plz, String name, double breitengrad, double längengrad) {
+	public Ort(int plz, String name) {
         this.plz = plz;
         this.name = name;
-        this.breitengrad = breitengrad;
-        this.längengrad = längengrad;
     }
 	
+	public Ort(int plz, String name, double breitengrad, double längengrad) {
+		this.plz = plz;
+		this.name = name;
+		this.breitengrad = breitengrad;
+		this.längengrad = längengrad;
+	}
+
+	
+	
+	
+	public String getAktuellesWetter() {
+		try {
+			return WetterService.getAktuellesWetter(name);
+		} catch (IOException | InterruptedException e) {
+			e.printStackTrace();
+			return "Fehler beim Abrufen des aktuellen Wetters";
+		}
+	}
 
 	public String getWettervorhersage() {
 
-		return "Wettervorhersage";
+		try {
+			return WetterService.getWettervorhersage(name);
+		} catch (IOException | InterruptedException e) {
+			e.printStackTrace();
+			return "Fehler beim Abrufen der Wettervorhersage";
+		}
 	}
 
 
@@ -38,5 +59,6 @@ public class Ort {
 	
 	public double getLängengrad() {
 		return längengrad;
+		
 	}
 }

TravelBuddyApp/src/main/java/domain/Reiseplanung.java

@@ -1,5 +1,70 @@
 package domain;
 
+import java.lang.Math;
+
 public class Reiseplanung {
 
+	private Ort standort;
+	private Ort zielort;
+	private double entfernung;
+	private double dauerPKW;
+	private double dauerFahrrad;
+	private double co2AusstoßPKW;
+
+	public Reiseplanung(User user, Ort zielort) {
+		this.standort = user.getHeimatstandort();
+		this.zielort = zielort;
+		this.entfernung = berechneEntfernung(standort, zielort);
+		this.dauerPKW = berechneDauer(user.getDurchschnittsgeschwindigkeitPKW());
+		this.dauerFahrrad = berechneDauer(user.getDurchschnittsgeschwindigkeitFahrrad());
+		this.co2AusstoßPKW = berechneCO2Ausstoß(user.getAuto());
+	}
+
+	public double berechneEntfernung(Ort standort, Ort zielort) {
+
+		double b1 = Math.toRadians(standort.getBreitengrad());
+		double b2 = Math.toRadians(zielort.getBreitengrad());
+		double l1 = Math.toRadians(standort.getLängengrad());
+		double l2 = Math.toRadians(zielort.getLängengrad());
+
+		entfernung = (6378.388
+				* Math.acos(Math.sin(b1) * Math.sin(b2) + Math.cos(b1) * Math.cos(b2) * Math.cos(l2 - l1))) * 1.25;
+
+		return entfernung;
+	}
+
+	// berechnet die ungefähre Dauer zum gewählten Ort
+	public double berechneDauer(double geschwindigkeit) {
+		return entfernung / geschwindigkeit;
+
+	}
+
+	// berechnet ungefähren CO2 Ausstoß des Autos für eine Strecke
+	public double berechneCO2Ausstoß(Auto auto) {
+		return entfernung * auto.getCO2AusstossProKm();
+	}
+
+	public double getEntfernung() {
+		return Math.round(entfernung*100.0)/100.0;
+
+	}
+
+	@Override
+	public String toString() {
+		return String.format(
+				"Von %s nach %s\nEntfernung: %.1f km\nReisedauer mit dem PKW: %.1f Stunden\nReisedauer mit dem Fahrrad: %.1f Stunden\nCO2-Ausstoß durch PKW: %.1f kg",
+				standort.getName(), zielort.getName(), entfernung, dauerPKW, dauerFahrrad, co2AusstoßPKW);
+	}
+
+	public double getDauerPKW() {
+		return dauerPKW;
+	}
+
+	public double getDauerFahrrad() {
+		return dauerFahrrad;
+	}
+
+	public double getCO2Ausstoß() {
+		return co2AusstoßPKW;
+	}
 }

TravelBuddyApp/src/main/java/domain/User.java

@@ -1,34 +1,132 @@
 package domain;
 
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import org.apache.commons.codec.digest.DigestUtils;
+
 public class User {
 
 	private String username;
-	private String password;
+	private String hashedPassword;
 	private Ort heimatstandort;
-	private Auto auto;
+	public Auto auto;
 	private double durchschnittsgeschwindigkeitPKW;
 	private double durchschnittsgeschwindigkeitFahrrad;
 
 	public User(String username, String password, Ort heimatstandort, Auto auto, double durchschnittsgeschwindigkeitPKW,
 			double durchschnittsgeschwindigkeitFahrrad) {
+		
 		this.username = username;
-		this.password = password;
+		this.hashedPassword = hashPassword(password);
 		this.heimatstandort = heimatstandort;
 		this.auto = auto;
 		this.durchschnittsgeschwindigkeitPKW = durchschnittsgeschwindigkeitPKW;
 		this.durchschnittsgeschwindigkeitFahrrad = durchschnittsgeschwindigkeitFahrrad;
 	}
 
+	private String hashPassword(String password) {
+		return DigestUtils.sha256Hex(password); // Hash-Funktion verwenden
+	}
+
+	public String getUsername() {
+		return username;
+	}
+
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	public String getHashedPassword() {
+		return hashedPassword;
+	}
+
+	public void setPassword(String password) {
+		this.hashedPassword = hashPassword(password); // Passwort hashen beim Setzen
+	}
+
+	public Ort getHeimatstandort() {
+		return heimatstandort;
+	}
+
+	public void setHeimatstandort(Ort heimatstandort) {
+		this.heimatstandort = heimatstandort;
+	}
+
+	public Auto getAuto() {
+		return auto;
+	}
+
+	public void setAuto(Auto auto) {
+		this.auto = auto;
+	}
+
+	public double getDurchschnittsgeschwindigkeitPKW() {
+		return durchschnittsgeschwindigkeitPKW;
+	}
+
+	public void setDurchschnittsgeschwindigkeitPKW(double durchschnittsgeschwindigkeitPKW) {
+		this.durchschnittsgeschwindigkeitPKW = durchschnittsgeschwindigkeitPKW;
+	}
+
+	public double getDurchschnittsgeschwindigkeitFahrrad() {
+		return durchschnittsgeschwindigkeitFahrrad;
+	}
+
+	public void setDurchschnittsgeschwindigkeitFahrrad(double durchschnittsgeschwindigkeitFahrrad) {
+		this.durchschnittsgeschwindigkeitFahrrad = durchschnittsgeschwindigkeitFahrrad;
+	}
+
 	public void registrieren() {
-		// Implementierung der Registrierung
+
+		try (PrintWriter writer = new PrintWriter(new FileWriter("users.txt", true))) {
+			writer.println(username + "," + hashedPassword + "," + heimatstandort.getPLZ() + ","
+					+ heimatstandort.getName() + "," + auto.getName() + "," + auto.getCO2AusstossProKm() + ","
+					+ durchschnittsgeschwindigkeitPKW + "," + durchschnittsgeschwindigkeitFahrrad);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+
 	}
 
-	public void einloggen() {
-		// Implementierung des Logins
+	public boolean einloggen() {
+		
+	    try (BufferedReader reader = new BufferedReader(new FileReader("users.txt"))) {
+	        String line;
+	        while ((line = reader.readLine()) != null) {
+	            String[] parts = line.split(",");
+	            if (parts[0].equals(username) && parts[1].equals(hashedPassword)) {
+	                int plz = Integer.parseInt(parts[2]);
+	                this.heimatstandort = new Ort(plz, parts[3]);
+	                this.auto = new Auto(parts[4], Double.parseDouble(parts[5]));
+	                this.durchschnittsgeschwindigkeitPKW = Double.parseDouble(parts[6]);
+	                this.durchschnittsgeschwindigkeitFahrrad = Double.parseDouble(parts[7]);
+	                return true;
+	            }
+	        }
+	    } catch (IOException e) {
+	        e.printStackTrace();
+	    }
+	    return false;
 	}
 	
-	public void zeigeWetterHeimatstandort() {
-		// Implementierung der Wetteranzeige
+
+	public String zeigeWetterHeimatstandort() {
+		try {
+			return WetterService.getAktuellesWetter(heimatstandort.getName());
+		} catch (IOException | InterruptedException e) {
+			return "Fehler beim Abrufen des Wetters: " + e.getMessage();
+		}
+	}
+
+	public String zeigeWettervorhersageHeimatstandort() {
+		try {
+			return WetterService.getWettervorhersage(heimatstandort.getName());
+		} catch (IOException | InterruptedException e) {
+			return "Fehler beim Abrufen der Wettervorhersage: " + e.getMessage();
+		}
 	}
 
 }

TravelBuddyApp/src/main/java/domain/WetterService.java

@@ -1,6 +1,79 @@
 package domain;
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.Map;
+import org.json.JSONArray;
+import org.json.JSONObject;
 
 public class WetterService {
 
 	
+	private static final String API_KEY = "fc01dfd47f80659f12512c295e80b201";
+	private static final HttpClient client = HttpClient.newHttpClient();
+
+	public static String getAktuellesWetter(String location) throws IOException, InterruptedException {
+
+		String url = "http://api.openweathermap.org/data/2.5/weather?q=" + location + "&appid=" + API_KEY
+				+ "&units=metric";
+		HttpRequest request = HttpRequest.newBuilder().uri(URI.create(url)).build();
+		HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+		if (response.statusCode() != 200) {
+			throw new IOException("Unerwarteter Code " + response.statusCode());
+		}
+
+		JSONObject json = new JSONObject(response.body());
+		double temp = json.getJSONObject("main").getDouble("temp");
+		String weather = json.getJSONArray("weather").getJSONObject(0).getString("description");
+
+		return "Aktuelle Temperatur: " + temp + "°C, Wetter: " + weather;
+	}
+	
+	public static String getWettervorhersage(String location) throws IOException, InterruptedException {
+
+		String url = "http://api.openweathermap.org/data/2.5/forecast?q=" + location + "&appid=" + API_KEY
+				+ "&units=metric";
+		HttpRequest request = HttpRequest.newBuilder().uri(URI.create(url)).build();
+		HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+		if (response.statusCode() != 200) {
+			throw new IOException("Unerwarteter Code " + response.statusCode());
+		}
+
+		JSONObject json = new JSONObject(response.body());
+		Map<String, Double> tempByDay = new HashMap<>();
+		Map<String, String> weatherByDay = new HashMap<>();
+		LocalDate today = LocalDate.now();
+		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+
+		JSONArray forecastList = json.getJSONArray("list");
+		for (int i = 0; i < forecastList.length(); i++) {
+			JSONObject forecastEntry = forecastList.getJSONObject(i);
+			String dateTime = forecastEntry.getString("dt_txt");
+			String date = dateTime.split(" ")[0];
+			LocalDate forecastDate = LocalDate.parse(date, formatter);
+
+			if (forecastDate.isAfter(today) && !tempByDay.containsKey(date)) {
+				double temp = forecastEntry.getJSONObject("main").getDouble("temp");
+				String weather = forecastEntry.getJSONArray("weather").getJSONObject(0).getString("description");
+
+				tempByDay.put(date, temp);
+				weatherByDay.put(date, weather);
+			}
+		}
+
+		StringBuilder forecast = new StringBuilder("3-Tage-Wettervorhersage:\n");
+		tempByDay.keySet().stream().sorted().limit(3).forEach(date -> {
+			forecast.append(String.format("%s - Temperatur: %.2f°C, Wetter: %s\n", date, tempByDay.get(date),
+					weatherByDay.get(date)));
+		});
+
+		return forecast.toString();
+	}
 }

TravelBuddyApp/src/main/java/fassade/ReiseFassade.java

@@ -1,69 +1,169 @@
 package fassade;
 
-import java.io.File;
-import java.io.FileNotFoundException;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
 import java.util.HashSet;
-import java.util.Scanner;
-import java.util.Set;
 
 import domain.Ort;
 import domain.Reiseplanung;
 import domain.User;
+import domain.WetterService;
+
+import java.util.List;
+import java.util.Set;
+
+import domain.KurztripEmpfehlung;
 
 public class ReiseFassade {
 
+	private Reiseplanung reiseplanung;
+	private KurztripEmpfehlung kurztripEmpfehlung;
 	User user;
-	private Set<Ort> orte;
+	List<Ort> alleOrte;
 
-	public ReiseFassade(User user) throws FileNotFoundException {
+	public ReiseFassade(User user) {
+
+		this.kurztripEmpfehlung = new KurztripEmpfehlung();
+		alleOrte = ladeAlleOrte();
 		
-		orte = new HashSet<>();
 
-		orteLaden();
 	}
 	
-	//lädt Datei aus rescources ein und speichert Orte in HashSet ab
-	private void orteLaden() throws FileNotFoundException {
+	 public void setHeimatortFromUser(User user) {
+	        Ort heimatort = user.getHeimatstandort();
+	        this.kurztripEmpfehlung.setHeimatort(heimatort);
+	    }
 	
-		//UserInterface.class.getClass().getResourceAsStream("resources/PLZ.csv");
-		Scanner sc = new Scanner(new File("resources/PLZ.csv"));
 	
-		int zähler = 0;
-		while (sc.hasNextLine()) {
-			String ort = sc.nextLine();
 	 
-			String[] spalten = ort.split(";");
+	public List<Ort> ladeAlleOrte() {
+		List<Ort> alleOrte = new ArrayList<>();
 
-			orte.add(new Ort(Integer.parseInt(spalten[0]), spalten[1], Double.parseDouble(spalten[2]), Double.parseDouble(spalten[3])));
-			
-			zähler++;
-		}
-		
-		System.out.println(zähler + "Orte geladen.");
-	}
-	
-	//gibt Trefferliste passend zum Suchbegriff zurück
-	public String sucheOrt(String suchbegriff) {
-		Set<Ort> trefferliste = new HashSet<>();
-		String ausgabe;
-		
-		//gibt alle Orte zurück
-		if(suchbegriff.equals("alle"))
-			trefferliste = orte;
-		else
-			//läuft über set orte 
-			for(Ort o : orte) {
-				//fügt ort zur Trefferliste hinzu wenn der Suchbegriff im Namen ist und weniger als 8 Orte bereits drauf stehen 
-				if(o.getName().contains(suchbegriff) && trefferliste.size()<8)
-					trefferliste.add(o);
+		String csvFile = "src/main/resources/PLZ.csv";
+		String line;
+		try (BufferedReader br = new BufferedReader(new FileReader(csvFile))) {
+			while ((line = br.readLine()) != null) {
+				line = line.replaceAll("\\s+", "");
+				String[] data = line.split(";");
+				int plz = Integer.parseInt(data[0].replaceAll("\"", ""));
+				String ortName = data[1].replaceAll("\"", "");
+				double breitengrad = Double.parseDouble(data[2].replaceAll("\"", ""));
+				double laengengrad = Double.parseDouble(data[3].replaceAll("\"", ""));
+				Ort ort = new Ort(plz, ortName);
+				ort.breitengrad = breitengrad;
+				ort.längengrad = laengengrad;
+				alleOrte.add(ort);
 			}
-		
-		for(Ort o : trefferliste) {
-		ausgabe = ausgabe + o.getName() + " Entfernung: " + new Reiseplanung(user, o).getEntfernung() + "\n";
+		} catch (IOException e) {
+			System.err.println("Fehler beim Lesen der Datei: " + e.getMessage());
+			e.printStackTrace();
+		} catch (NumberFormatException | ArrayIndexOutOfBoundsException e) {
+			System.err.println("Fehlerhaftes Datenformat in der CSV-Datei: " + e.getMessage());
+			e.printStackTrace();
 		}
 
-		return ausgabe;
+		return alleOrte;
 	}
 
 
+	
+	public Ort[] sucheOrt(String suchbegriff) {
+        Set<Ort> trefferSet = new HashSet<>();
+
+        if (suchbegriff.equalsIgnoreCase("alle")) {
+            trefferSet.addAll(alleOrte);
+        } else {
+            for (Ort o : alleOrte) {
+                if (o.getName().contains(suchbegriff) && trefferSet.size() < 8) {
+                    trefferSet.add(o);
+                }
+            }
+        }
+
+        return trefferSet.toArray(new Ort[0]);
+    }
+
+	
+	
+	
+	public String anzeigeTrefferliste(Ort[] trefferliste) {
+        StringBuilder ausgabe = new StringBuilder();
+        int i = 1;
+
+        for (Ort o : trefferliste) {
+            double entfernung = new Reiseplanung(user, o).getEntfernung();
+            ausgabe.append(i).append(". ").append(o.getName()).append(" (Entfernung: ")
+                  .append(entfernung).append(" km)\n");
+            String wettervorhersage = getWettervorhersage(o.getName());
+            ausgabe.append(wettervorhersage).append("\n");
+            i++;
+        }
+
+        return ausgabe.toString();
+    }
+
+	
+	public String ortAnzeige(int index, Ort[] trefferliste) {
+		String anzeige = " ";
+		anzeige = trefferliste[index - 1].getName() + " " + trefferliste[index - 1].getPLZ() + " " 
+				+ trefferliste[index - 1].getWettervorhersage();
+		return anzeige;
+	}
+
+	
+	
+	
+	public String getReiseplanung(User user, Ort ziel) {
+		reiseplanung = new Reiseplanung(user, ziel);
+		return reiseplanung.toString();
+	}
+
+
+
+	public String getAktuellesWetter(String ortName) {
+        try {
+            return WetterService.getAktuellesWetter(ortName);
+        } catch (IOException | InterruptedException e) {
+            return "Fehler beim Abrufen des Wetters: " + e.getMessage();
+        }
+    }
+	
+	
+	 public String getWettervorhersage(String ortName) {
+	        try {
+	            return WetterService.getWettervorhersage(ortName);
+	        } catch (IOException | InterruptedException e) {
+	            return "Fehler beim Abrufen des Wetters: " + e.getMessage();
+	        }
+	    }
+
+	
+	public double berechneEntfernung() {
+		return reiseplanung.getEntfernung();
+	}
+
+	public String berechneReiseDauerPKW() {
+		double dauer = reiseplanung.berechneDauer(reiseplanung.getDauerPKW());
+		return String.format("Die Reise dauert ca. %.2f Stunden.", dauer);
+	}
+
+	public String berechneReiseDauerFahrrad() {
+		double dauer = reiseplanung.berechneDauer(reiseplanung.getDauerFahrrad());
+		return String.format("Die Reise dauert ca. %.2f Stunden.", dauer);
+	}
+
+	public double berechneCO2AusstossPKW() {
+		return reiseplanung.getCO2Ausstoß();
+	}
+
+	public List<Ort> zufallsorteFahrrad(int maxEntfernung) {
+		return kurztripEmpfehlung.zufallsorteFahrrad(maxEntfernung);
+	}
+
+	public List<Ort> zufallsortePKW(int minEntfernung) {
+		return kurztripEmpfehlung.zufallsortePKW(minEntfernung);
+	}
+
 }

TravelBuddyApp/src/main/java/fassade/UserFassade.java

@@ -1,5 +1,48 @@
 package fassade;
 
+import domain.User;
+import domain.Ort;
+import domain.Auto;
+
 public class UserFassade {
 
+
+	public User registrieren(String username, String password, int plz, String ortName, String autoName,
+			double co2AusstossProKm, double durchschnittsgeschwindigkeitPKW,
+			double durchschnittsgeschwindigkeitFahrrad) {
+		Ort heimatstandort = new Ort(plz, ortName);
+		Auto auto = new Auto(autoName, co2AusstossProKm);
+		User user = new User(username, password, heimatstandort, auto, durchschnittsgeschwindigkeitPKW,
+				durchschnittsgeschwindigkeitFahrrad);
+		user.registrieren();
+		return user;
+	}
+
+	public User einloggen(String username, String password) {
+		
+		User user = new User(username, password, null, null, 0, 0);
+		if (user.einloggen()) {
+			return user;
+		}
+		return null;
+	}
+
+	public void zeigeWetterHeimatstandort(User user) {
+		try {
+			String aktuellesWetter = user.zeigeWetterHeimatstandort();
+			System.out.println(aktuellesWetter);
+		} catch (Exception e) {
+			System.err.println("Fehler beim Abrufen des aktuellen Wetters: " + e.getMessage());
+		}
+	}
+
+	public void zeigeWettervorhersageHeimatstandort(User user) {
+		try {
+			String wettervorhersage = user.zeigeWettervorhersageHeimatstandort();
+			System.out.println(wettervorhersage);
+		} catch (Exception e) {
+			System.err.println("Fehler beim Abrufen der Wettervorhersage: " + e.getMessage());
+		}
+	}
+
 }

TravelBuddyApp/src/main/java/ui/UserInterface.java

@@ -1,5 +1,277 @@
 package ui;
 
+import java.util.List;
+import java.util.Scanner;
+
+import domain.KurztripEmpfehlung;
+import domain.Ort;
+import domain.Reiseplanung;
+import domain.User;
+import fassade.ReiseFassade;
+import fassade.UserFassade;
+
 public class UserInterface {
 
+	private UserFassade userFacade;
+	private ReiseFassade reiseFacade;
+	private User user;
+	private Scanner scanner;
+
+	public UserInterface() {
+
+		this.reiseFacade = new ReiseFassade(user);
+		this.userFacade = new UserFassade();
+		this.scanner = new Scanner(System.in);
+		start();
+	}
+
+	public void start() {
+
+		boolean exit = false;
+		System.out.println("\t\t\t Willkommen zur Travel-Buddy-App!");
+		System.out.println("\t\t\t --------------------------------");
+		
+		while (!exit) {
+			System.out.println("1. Registrieren");
+			System.out.println("2. Einloggen");
+			System.out.println("3. Suche Ort");
+			System.out.println("4. Plane Reise");
+			System.out.println("5. Kurztrip empfehlen");
+			System.out.println("6. Beenden");
+			System.out.print("Wählen Sie eine Option: ");
+
+			int option = Integer.parseInt(scanner.nextLine());
+			System.out.println("\n================================================================================");
+
+			switch (option) {
+			case 1:
+				registrieren();
+				System.out
+						.println("\n================================================================================");
+				break;
+			case 2:
+				einloggen();
+				System.out
+						.println("\n================================================================================");
+				break;
+			case 3:
+				sucheOrt();
+				System.out
+						.println("\n================================================================================");
+				break;
+			case 4:
+				planeReise();
+				System.out
+						.println("\n================================================================================");
+				break;
+			case 5:
+				kurztripEmpfehlen();
+				System.out
+						.println("\n================================================================================");
+				break;
+			case 6:
+				System.out.println("Auf Wiedersehen!");
+				return;
+			default:
+				System.out.println("Ungültige Option. Bitte wählen Sie eine gültige Option.");
+			}
+		}
+
+	}
+
+	private void registrieren() {
+		System.out.print("Geben Sie einen Benutzernamen ein: ");
+		String username = scanner.nextLine();
+		System.out.print("Geben Sie ein Passwort ein: ");
+		String password = scanner.nextLine();
+		System.out.print("Geben Sie Ihre Heimat-PLZ ein: ");
+		int plz = Integer.parseInt(scanner.nextLine());
+		System.out.print("Geben Sie Ihren Heimatort ein: ");
+		String ortName = scanner.nextLine();
+		System.out.print("Geben Sie den Namen Ihres Autos ein: ");
+		String autoName = scanner.nextLine();
+		System.out.print("Geben Sie den CO2-Ausstoß Ihres Autos (g/km) ein: ");
+		double co2Ausstoss = Double.parseDouble(scanner.nextLine());
+		System.out.print("Geben Sie die Durchschnittsgeschwindigkeit Ihres Autos (km/h) ein: ");
+		double durchschnittsgeschwindigkeitPKW = Double.parseDouble(scanner.nextLine());
+		System.out.print("Geben Sie die Durchschnittsgeschwindigkeit Ihres Fahrrads (km/h) ein: ");
+		double durchschnittsgeschwindigkeitFahrrad = Double.parseDouble(scanner.nextLine());
+
+		userFacade.registrieren(username, password, plz, ortName, autoName, co2Ausstoss,
+				durchschnittsgeschwindigkeitPKW, durchschnittsgeschwindigkeitFahrrad);
+
+		User user = userFacade.einloggen(username, password); // Fügen Sie dies hinzu, um den Benutzer nach der
+																// Registrierung automatisch einzuloggen
+		if (user != null) {
+			this.user = user;
+			reiseFacade.setHeimatortFromUser(user);
+			System.out.println("\nRegistrierung und automatischer Login erfolgreich! Willkommen, " + username + "!");
+		} else {
+			System.out.println("\nRegistrierung erfolgreich, aber automatischer Login fehlgeschlagen.");
+		}
+
+	}
+
+	private void einloggen() {
+		System.out.print("Geben Sie Ihren Benutzernamen ein: ");
+		String username = scanner.nextLine();
+		System.out.print("Geben Sie Ihr Passwort ein: ");
+		String password = scanner.nextLine();
+
+		User user = userFacade.einloggen(username, password);
+		if (user != null) {
+			this.user = user;
+			reiseFacade.setHeimatortFromUser(user);
+			System.out.println("\nLogin erfolgreich! Willkommen zurück, " + user.getUsername() + "!");
+			String wetter = user.zeigeWetterHeimatstandort();
+			System.out.println("Aktuelles Wetter in " + user.getHeimatstandort().getName() + ": " + wetter);
+		} else {
+			System.out.println("\nBenutzername oder Passwort ist falsch:(");
+		}
+	}
+
+	
+	
+	private void sucheOrt() {
+        System.out.print("Geben Sie den Namen des Ortes ein: ");
+        String ortName = scanner.nextLine();
+
+        // Search for the location
+        Ort[] treffer = reiseFacade.sucheOrt(ortName);
+
+        if (treffer.length == 0) {
+            System.out.println("Keine Treffer gefunden.");
+        } else {
+            System.out.println("Trefferliste:");
+            for (int i = 0; i < treffer.length; i++) {
+                Reiseplanung reiseplanung = new Reiseplanung(user, treffer[i]);
+                System.out.println((i + 1) + ". " + treffer[i].getName() + " (PLZ: " + treffer[i].getPLZ() + 
+                                   "), Entfernung: " + reiseplanung.getEntfernung() + " km");
+
+                String wettervorhersage = reiseFacade.getWettervorhersage(treffer[i].getName());
+                System.out.println(wettervorhersage);
+            }
+
+            // Display the current weather at the user's home location
+            String wetter = reiseFacade.getAktuellesWetter(user.getHeimatstandort().getName());
+            System.out.println("Aktuelles Wetter in " + user.getHeimatstandort().getName() + ": " + wetter);
+
+            // Choose a location from the list
+            System.out.println("Wählen Sie einen Ort aus: ");
+            System.out.println("Geben Sie 'beenden' ein, um zu beenden");
+            String input = scanner.nextLine();
+
+            if (input.equalsIgnoreCase("beenden")) {
+                return;
+            }
+
+            try {
+                int eingabe = Integer.parseInt(input);
+                if (eingabe < 1 || eingabe > treffer.length) {
+                    System.out.println("Ungültige Auswahl. Bitte versuchen Sie es erneut.");
+                } else {
+                    System.out.println(reiseFacade.ortAnzeige(eingabe, treffer));
+                }
+            } catch (NumberFormatException e) {
+                System.out.println("Ungültige Eingabe. Bitte geben Sie eine Zahl ein.");
+            }
+        }
+    }
+	
+	
+	
+	
+	
+	
+
+	private void planeReise() {
+	    System.out.print("Geben Sie die Ziel-PLZ ein: ");
+	    int zielPlz = Integer.parseInt(scanner.nextLine());
+	    System.out.print("Geben Sie den Zielort ein: ");
+	    String zielOrtName = scanner.nextLine();
+	    
+	    // Lade alle Orte, um den Ort mit den GPS-Koordinaten zu erhalten
+	    List<Ort> alleOrte = reiseFacade.ladeAlleOrte();
+	    Ort zielort = null;
+	    for (Ort ort : alleOrte) {
+	        if (ort.getPLZ() == zielPlz && ort.getName().equalsIgnoreCase(zielOrtName)) {
+	            zielort = ort;
+	            break;
+	        }
+	    }
+
+	    if (zielort != null) {
+	        System.out.println(reiseFacade.getReiseplanung(user, zielort));
+	    } else {
+	        System.out.println("Der Zielort wurde nicht gefunden.");
+	    }
+	}
+	
+	
+	
+
+	private void kurztripEmpfehlen() {
+		if (user != null && user.getHeimatstandort() != null) {
+			System.out.println("Empfehlung basiert auf Heimatort: " + user.getHeimatstandort().getName());
+
+			reiseFacade.setHeimatortFromUser(user);
+
+			System.out.print("Wählen Sie ein Transportmittel (Fahrrad/Auto): ");
+			String transportmittel = scanner.nextLine().trim().toLowerCase();
+
+			List<Ort> empfohleneOrte = null;
+			switch (transportmittel) {
+			case "fahrrad":
+				empfohleneOrte = reiseFacade.zufallsorteFahrrad(10000);
+				//List<Ort> fahrradOrte = reiseFacade.zufallsorteFahrrad(10000);
+				/*if (fahrradOrte.isEmpty()) {
+					System.out.println("Keine Orte innerhalb von 100 km gefunden.");
+				} else {
+					System.out.println("Folgende Orte wurden für einen Fahrrad-Kurztrip empfohlen:");
+					for (Ort ort : fahrradOrte) {
+						System.out.println("- " + ort.getOrtName() + " (PLZ: " + ort.getPLZ() + ")");
+					}
+				}*/
+				break;
+			case "auto":
+				empfohleneOrte = reiseFacade.zufallsortePKW(150);
+				//List<Ort> autoOrte = reiseFacade.zufallsortePKW(150);
+				/*if (autoOrte.isEmpty()) {
+					System.out.println("Keine Orte mindestens 150 km entfernt gefunden.");
+				} else {
+					System.out.println("Folgende Orte wurden für einen Auto-Kurztrip empfohlen:");
+					for (Ort ort : autoOrte) {
+						System.out.println("- " + ort.getOrtName() + " (PLZ: " + ort.getPLZ() + ")");
+					}
+				}*/
+				break;
+			default:
+				System.out.println("Ungültige Option. Bitte wählen Sie entweder 'Fahrrad' oder 'Auto'.");
+				break;
+			}
+			
+			
+			 if (!empfohleneOrte.isEmpty()) {
+		            System.out.println("Empfohlene Orte:");
+		            KurztripEmpfehlung kurztripEmpfehlung = new KurztripEmpfehlung();
+		            for (Ort ort : empfohleneOrte) {
+		                double entfernung = kurztripEmpfehlung.berechneEntfernung(user.getHeimatstandort(), ort);
+		                System.out.printf("- %s (PLZ: %d, Entfernung: %.1f km)%n", ort.getName(), ort.getPLZ(), entfernung);
+		            }
+		        } else {
+		            System.out.println("Keine Orte gefunden.");
+		        }
+			
+			
+		} else {
+			System.out.println("Bitte zuerst einloggen und Heimatort angeben!");
+		}
+	}
+	
+	
+	public static void main(String[] args) {
+		new UserInterface();
+
+	}
+
 }

TravelBuddyApp/src/test/java/UserTest.java

@@ -1,4 +0,0 @@
-
-public class UserTest {
-
-}

TravelBuddyApp/src/test/java/domain/ReiseplanungTest.java

@@ -0,0 +1,80 @@
+package domain;
+
+import static org.junit.Assert.assertEquals;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ReiseplanungTest {
+
+    private Auto auto;
+    private Ort startOrt;
+    private Ort zielOrt;
+    private User user;
+    private Reiseplanung reiseplanung;
+
+    @Before
+    public void setUp() {
+        auto = new Auto("Brummi", 167.6); // CO2-Ausstoß in g/km
+        startOrt = new Ort(1067, "Dresden", 13.7210676148814, 51.0600336463379);
+        user = new User("Karl", "hallo", startOrt, auto, 70, 15); // Durchschnittsgeschwindigkeit PKW und Fahrrad
+        zielOrt = new Ort(1705, "Freital", 13.6382950999229, 50.9981963286759);
+        reiseplanung = new Reiseplanung(user, zielOrt);
+    }
+
+    @Test
+    public void testBerechneEntfernung() {
+        double result = reiseplanung.berechneEntfernung(startOrt, zielOrt);
+        // This value needs to be verified and adjusted if necessary
+        assertEquals(14.2125, result, 0.1);
+    }
+
+    @Test
+    public void testBerechneDauer() {
+        double entfernung = 136.5;
+        double geschwindigkeit = 70; // Durchschnittsgeschwindigkeit in km/h
+        double result = reiseplanung.berechneDauer(geschwindigkeit);
+        assertEquals(1.95, result, 0.01);
+    }
+
+    @Test
+    public void testBerechneCO2Ausstoß() {
+        double entfernung = 73.8;
+        double result = reiseplanung.berechneCO2Ausstoß(auto);
+        assertEquals(12368.88, result, 0.01);
+    }
+
+    @Test
+    public void testGetEntfernung() {
+        assertEquals(14.2125, reiseplanung.getEntfernung(), 0.1);
+    }
+
+    @Test
+    public void testGetDauerPKW() {
+        double geschwindigkeit = user.getDurchschnittsgeschwindigkeitPKW();
+        double erwarteteDauer = 14.2125 / geschwindigkeit;
+        assertEquals(erwarteteDauer, reiseplanung.getDauerPKW(), 0.1);
+    }
+
+    @Test
+    public void testGetDauerFahrrad() {
+        double geschwindigkeit = user.getDurchschnittsgeschwindigkeitFahrrad();
+        double erwarteteDauer = 14.2125 / geschwindigkeit;
+        assertEquals(erwarteteDauer, reiseplanung.getDauerFahrrad(), 0.1);
+    }
+
+    @Test
+    public void testGetCO2Ausstoß() {
+        double erwarteterCO2Ausstoß = 14.2125 * auto.getCO2AusstossProKm();
+        assertEquals(erwarteterCO2Ausstoß, reiseplanung.getCO2Ausstoß(), 0.1);
+    }
+
+    @Test
+    public void testToString() {
+        String expected = "Von " + startOrt.getName() + " Nach " + zielOrt.getName() + 
+                          "\nEntfernung: " + reiseplanung.getEntfernung() + 
+                          "\nReisedauer mit dem PKW: " + reiseplanung.getDauerPKW() + 
+                          "\nReisedauer mit dem Fahrrad: " + reiseplanung.getDauerFahrrad() + 
+                          "\nCO2-Ausstoß durch PKW: " + reiseplanung.getCO2Ausstoß();
+        assertEquals(expected, reiseplanung.toString());
+    }
+}

TravelBuddyApp/src/test/java/domainTest/KurztripEmpfehlungTest.java

@@ -0,0 +1,55 @@
+package domainTest;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import domain.KurztripEmpfehlung;
+import domain.Ort;
+
+public class KurztripEmpfehlungTest {
+
+	private KurztripEmpfehlung empfehlung;
+    private Ort berlin;
+    private Ort dresden;
+    
+    @Before
+    public void setUp() {
+        empfehlung = new KurztripEmpfehlung();
+        berlin = new Ort(10115, "Berlin", 52.5200, 13.4050);
+        dresden = new Ort(1067, "Dresden", 51.0600336463379, 13.7210676148814);
+    }
+    
+    @Test
+    public void testSetHeimatort() {
+        empfehlung.setHeimatort(berlin);
+        assertEquals(berlin, empfehlung.getHeimatort());
+    }
+
+    @Test
+    public void testZufallsorteFahrrad() {
+        empfehlung.setHeimatort(berlin);
+        List<Ort> orte = empfehlung.zufallsorteFahrrad(100);
+        assertFalse(orte.isEmpty());
+        assertTrue(orte.size() <= 3);
+        for (Ort ort : orte) {
+            assertTrue(empfehlung.berechneEntfernung(berlin, ort) <= 100);
+        }
+    }
+
+    @Test
+    public void testZufallsortePKW() {
+        empfehlung.setHeimatort(berlin);
+        List<Ort> orte = empfehlung.zufallsortePKW(150);
+        assertFalse(orte.isEmpty());
+        assertTrue(orte.size() <= 3);
+        for (Ort ort : orte) {
+            assertTrue(empfehlung.berechneEntfernung(berlin, ort) >= 150);
+        }
+    }
+}

TravelBuddyApp/src/test/java/domainTest/UserTest.java

@@ -0,0 +1,92 @@
+package domainTest;
+
+import domain.Auto;
+import domain.Ort;
+import domain.User;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class UserTest {
+
+	private User testUser;
+    private final String testFilename = "users.txt";
+
+    @Before
+    public void setUp() {
+        Ort ort = new Ort(12345, "Teststadt");
+        Auto auto = new Auto("Testauto", 0.12);
+        testUser = new User("testuser", "password", ort, auto, 80.0, 15.0);
+    }
+
+    @After
+    public void tearDown() {
+        // Löschen der temporären Testdatei nach jedem Test
+        File file = new File(testFilename);
+        if (file.exists()) {
+            file.delete();
+        }
+    }
+	
+    @Test
+    public void testRegistrieren() throws IOException {
+        // Führe die Registrierung durch
+        testUser.registrieren();
+
+        // Überprüfe, ob die Daten korrekt in die Datei geschrieben wurden
+        try (BufferedReader reader = new BufferedReader(new FileReader(testFilename))) {
+            String line = reader.readLine();
+            assertEquals("testuser," + testUser.getHashedPassword() + ",12345,Teststadt,Testauto,0.12,80.0,15.0", line);
+        }
+    }
+	
+	
+	
+    @Test
+    public void testEinloggen() throws IOException {
+        // Vorbereitung der Testdaten in einer temporären Datei
+        try (PrintWriter writer = new PrintWriter(testFilename)) {
+            writer.println("testuser," + testUser.getHashedPassword() + ",12345,Teststadt,Testauto,0.12,80.0,15.0");
+        }
+
+        // Einloggen des Users
+        assertTrue(testUser.einloggen());
+
+        // Überprüfe, ob die Userdaten korrekt gesetzt wurden
+        assertEquals("Teststadt", testUser.getHeimatstandort().getName());
+        assertEquals("Testauto", testUser.getAuto().getName());
+        assertEquals(0.12, testUser.getAuto().getCO2AusstossProKm(), 0.001); // Delta für Genauigkeit
+        assertEquals(80.0, testUser.getDurchschnittsgeschwindigkeitPKW(), 0.001); // Delta für Genauigkeit
+        assertEquals(15.0, testUser.getDurchschnittsgeschwindigkeitFahrrad(), 0.001); // Delta für Genauigkeit
+    }
+    
+    
+    
+    @Test
+    public void testEinloggen_FalscheDaten() throws IOException {
+        // Vorbereitung der Testdaten in einer temporären Datei
+        try (PrintWriter writer = new PrintWriter(testFilename)) {
+            writer.println("testuser," + testUser.getHashedPassword() + ",12345,Teststadt,Testauto,0.12,80.0,15.0");
+        }
+
+        // Ändere Passwort, um ein falsches Einloggen zu erzwingen
+        testUser.setPassword("wrongpassword");
+
+        // Einloggen des Users mit falschen Daten
+        assertFalse(testUser.einloggen());
+    }
+    
+    
+    
+}

TravelBuddyApp/src/test/java/domainTest/WetterServiceTest.java

@@ -0,0 +1,34 @@
+package domainTest;
+
+import static org.junit.Assert.assertTrue;
+import java.io.IOException;
+import org.junit.Test;
+import domain.WetterService;
+
+
+public class WetterServiceTest {
+
+	@Test
+	public void testGetAktuellesWetter() throws IOException, InterruptedException {
+		String location = "Berlin";
+		String expectedWeatherRegex = "Aktuelle Temperatur: \\d+\\.\\d+°C, Wetter: .*";
+
+		String result = WetterService.getAktuellesWetter(location);
+
+		assertTrue("Expected weather format not found in result", result.matches(expectedWeatherRegex));
+	}
+	
+	@Test
+    public void testGetWettervorhersage() throws IOException, InterruptedException {
+        String location = "Berlin";
+        String expectedForecastStart = "3-Tage-Wettervorhersage:";
+
+        String result = WetterService.getWettervorhersage(location);
+
+        assertTrue("Expected forecast start not found in result", result.startsWith(expectedForecastStart));
+    }
+	
+	
+}
+
+

TravelBuddyApp/users.txt

@@ -0,0 +1,6 @@
+max,5994471abb01112afcc18159f6cc74b4f511b99806da59b3caf5a9c173cacfc5,10115,Berlin,VW,120.0,60.0,20.0
+lisa,0ffe1abd1a08215353c233d6e009613e95eec4253832a761af28ff37ac5a150c,80331,Münnchen,auto,120.0,60.0,30.0
+anna,9b8769a4a742959a2d0298c36fb70623f2dfacda8436237df08d8dfd5b37374c,76131,Karlsruhe,auto1,110.0,60.0,20.0
+mike,20f3765880a5c269b747e1e906054a4b4a3a991259f1e16b5dde4742cec2319a,68159,Mannheim,auti2,130.0,50.0,20.0
+sven,e0bc60c82713f64ef8a57c0c40d02ce24fd0141d5cc3086259c19b1e62a62bea,69115,Heidelberg,auto3,120.0,60.0,30.0
+