merge ohne Konflikte

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>
+			<groupId>junit</groupId>
-			<artifactId>junit-jupiter-api</artifactId>
+			<artifactId>junit</artifactId>
-			<version>5.8.1</version>
+			<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>
@@ -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

@@ -11,9 +11,20 @@ public class Auto {
 		this.co2AusstossProKm = co2AusstossProKm;
 	}
 
-    public double getCO2AusstoßProKm() {
+	public String getName() {
-    	return co2AusstossProKm;
+		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,147 @@
 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 {
 
+	User user;
+	private List<Ort> alleOrte;
+	private Ort heimatort;
+
+	public KurztripEmpfehlung(User user) {
+		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) {
+			Reiseplanung reise = new Reiseplanung(user, ort);
+			double entfernung = reise.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, Math.min(3, gefilterteOrte.size()));
+	}
+
+	
+	
+	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) {
+			Reiseplanung reise = new Reiseplanung(user, ort);
+			double entfernung = reise.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, Math.min(3, gefilterteOrte.size()));
+	}
+
+	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 deltaL = l2 - l1;
+//	    double cosDeltaL = Math.cos(deltaL);
+//	    double acosArgument = Math.sin(b1) * Math.sin(b2) + Math.cos(b1) * Math.cos(b2) * cosDeltaL;
+//
+//	    acosArgument = Math.max(-1.0, Math.min(1.0, acosArgument));
+//
+//	    double entfernung = 6378.388 * Math.acos(acosArgument);
+//
+//	    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);
+				ort.breitengrad = breitengrad;
+				ort.längengrad = 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 Ort getHeimatort() {
+		return heimatort;
+	}
 }

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

@@ -1,26 +1,39 @@
 package domain;
 
-import java.util.Set;
+import java.io.IOException;
+
 
 public class Ort {
 
 	private int plz;
 	private String name;
-	private double breitengrad;
+	double breitengrad;
-	private double längengrad;
+	double längengrad;
 	
-	
+	public Ort(int plz, String name) {
-	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";
+		}
 	}
 
 

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

@@ -17,8 +17,8 @@ public class Reiseplanung {
 		Auto auto = user.getAuto();
 		standort = user.getHeimatstandort();
 		berechneEntfernung(this.standort, this.zielort);
-		dauerPKW = berechneDauer(entfernung, user.getDurchschnittsgeschwindigkeitPKW());
+		dauerPKW = berechneDauer(user.getDurchschnittsgeschwindigkeitPKW());
-		dauerFahrrad = berechneDauer(entfernung, user.getDurchschnittsgeschwindigkeitFahrrad());
+		dauerFahrrad = berechneDauer(user.getDurchschnittsgeschwindigkeitFahrrad());
 		berechneCO2Ausstoß(this.entfernung, auto);
 		
 	}
@@ -35,18 +35,18 @@ public class Reiseplanung {
 	}
 	
 	//berechnet die ungefähre Dauer zum gewählten Ort
-	public double berechneDauer(double entfernung, double geschwindigkeit) {
+	public double berechneDauer(double geschwindigkeit) {
 		return entfernung/geschwindigkeit;
 		
 	}
 	
 	//berechnet ungefähren CO2 Ausstoß des Autos für eine Strecke
 	public double berechneCO2Ausstoß(double entfernung, Auto auto) {
-		co2AusstoßPKW = entfernung * auto.getCO2AusstoßProKm();
+		co2AusstoßPKW = entfernung * auto.getCO2AusstossProKm();
 		return co2AusstoßPKW;
 	}
 	
-	public double getEntferung() {
+	public double getEntfernung() {
 		return entfernung;
 		
 	}
@@ -54,4 +54,31 @@ public class Reiseplanung {
 	public String toString() {
 		return "Von " + standort + " Nach " + zielort + "\nEntfernung: " + entfernung + "\nReisedauer mit dem PKW: " + dauerPKW + "\nReiserdauer mit dem Fahrrad: " + dauerFahrrad + "\nCO2-Ausstoß durch PKW: " + co2AusstoßPKW;
 	}
+
+//	public Reiseplanung(Ort standort, Ort zielort, double durchschnittsgeschwindigkeitPKW,
+//			double durchschnittsgeschwindigkeitFahrrad, double co2AusstossProKmPKW) {
+//		this.standort = standort;
+//		this.zielort = zielort;
+//		this.entfernung = berechneEntfernung(standort, zielort);
+//		this.dauerPKW = entfernung / durchschnittsgeschwindigkeitPKW;
+//		this.dauerFahrrad = entfernung / durchschnittsgeschwindigkeitFahrrad;
+//		this.co2AusstoßPKW = entfernung * co2AusstossProKmPKW;
+//	}
+	
+//	public String berechneReiseDauer(double durchschnittsgeschwindigkeit) {
+//		double dauer = entfernung / durchschnittsgeschwindigkeit;
+//		return String.format("Die Reise dauert ca. %.2f Stunden.", dauer);
+//	}
+
+	public double getDauerPKW() {
+		return dauerPKW;
+	}
+
+	public double getDauerFahrrad() {
+		return dauerFahrrad;
+	}
+	
+	public double getCO2Ausstoß() {
+		return co2AusstoßPKW;
+	}
 }

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

@@ -1,9 +1,16 @@
 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;
 	public Auto auto;
 	private double durchschnittsgeschwindigkeitPKW;
@@ -13,38 +20,112 @@ public class User {
 			double durchschnittsgeschwindigkeitFahrrad) {
 		
 		this.username = username;
-		this.password = password;
+		this.hashedPassword = hashPassword(password);
 		this.heimatstandort = heimatstandort;
 		this.auto = auto;
 		this.durchschnittsgeschwindigkeitPKW = durchschnittsgeschwindigkeitPKW;
 		this.durchschnittsgeschwindigkeitFahrrad = durchschnittsgeschwindigkeitFahrrad;
 	}
 
-	public void registrieren() {
+	private String hashPassword(String password) {
-		// Implementierung der Registrierung
+		return DigestUtils.sha256Hex(password); // Hash-Funktion verwenden
 	}
 
-	public void einloggen() {
+	public String getUsername() {
-		// Implementierung des Logins
+		return username;
 	}
 
-	public void zeigeWetterHeimatstandort() {
+	public void setUsername(String username) {
-		// Implementierung der Wetteranzeige
+		this.username = username;
 	}
 
-	public double getDurchschnittsgeschwindigkeitPKW() {
+	public String getHashedPassword() {
-		return durchschnittsgeschwindigkeitPKW;
+		return hashedPassword;
 	}
 
-	public double getDurchschnittsgeschwindigkeitFahrrad() {
+	public void setPassword(String password) {
-		return durchschnittsgeschwindigkeitFahrrad;
+		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() {
+
+		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 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 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,78 @@
 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

@@ -5,21 +5,26 @@ import java.io.FileNotFoundException;
 import java.util.HashSet;
 import java.util.Scanner;
 import java.util.Set;
-
 import domain.Ort;
 import domain.Reiseplanung;
 import domain.User;
+import java.util.List;
+import domain.KurztripEmpfehlung;
 
 public class ReiseFassade {
 
+
+private Reiseplanung reiseplanung;
+private KurztripEmpfehlung kurztripEmpfehlung;
 	User user;
 	private Set<Ort> orte;
 	
-	public ReiseFassade(User user) throws FileNotFoundException {
+	public ReiseFassade(User user) {
 	
 		orte = new HashSet<>();
 				
-//		orteLaden();
+	//	 this.kurztripEmpfehlung = new KurztripEmpfehlung();
+
 	}
 	
 //	//lädt Datei aus rescources ein und speichert Orte in HashSet ab
@@ -59,11 +64,56 @@ public class ReiseFassade {
 			}
 		
 		for(Ort o : trefferliste) {
-		ausgabe = ausgabe + o.getName() + " Entfernung: " + new Reiseplanung(user, o).getEntferung() + "\n";
+		ausgabe = ausgabe + o.getName() + " Entfernung: " + new Reiseplanung(user, o).getEntfernung() + "\n";
 		}
 		
 		return ausgabe;
 	}
 	
 	
+
+
+	/*public Reiseplanung planeReise(Ort startort, Ort zielort) {
+        Reiseplanung reiseplanung = new Reiseplanung(startort, zielort);
+        reiseplanung.berechneEntfernung();
+        reiseplanung.berechneReisedauerPKW();
+        reiseplanung.berechneReisedauerFahrrad();
+        reiseplanung.berechneCo2Ausstoss();
+        return reiseplanung;
+    }*/
+	
+    
+    public void setHeimatortFromUser(User user) {
+        kurztripEmpfehlung.setHeimatort(user.getHeimatstandort());
+    }
+    
+    
+	
+	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,46 @@
 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,215 @@
 package ui;
 
+import java.util.List;
+import java.util.Scanner;
+
+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();
+		/*
+		 * List<Ort> treffer = reiseFacade.sucheOrt(ortName); if (treffer.isEmpty()) {
+		 * System.out.println("Keine Treffer gefunden."); } else {
+		 * System.out.println("Trefferliste:"); for (Ort ort : treffer) {
+		 * System.out.println(ort.getOrtName() + " (PLZ: " + ort.getPLZ() + ")"); String
+		 * wetter = user.zeigeWettervorhersageHeimatstandort();
+		 * System.out.println("Aktuelles Wetter in " +
+		 * user.getHeimatstandort().getOrtName() + ": " + wetter); } }
+		 */
+	}
+
+	private void planeReise() {
+		System.out.print("Geben Sie Ihre Start-PLZ ein: ");
+		int startPlz = Integer.parseInt(scanner.nextLine());
+		System.out.print("Geben Sie Ihren Startort ein: ");
+		String startOrtName = scanner.nextLine();
+		Ort startort = new Ort(startPlz, startOrtName);
+		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();
+		Ort zielort = new Ort(zielPlz, zielOrtName);
+
+		/*
+		 * Reiseplanung reise = reiseFacade.planeReise(startort, zielort);
+		 * System.out.println("Reiseplanung:"); System.out.println("Entfernung: " +
+		 * reise.getEntfernung() + " km"); System.out.println("Reisedauer PKW: " +
+		 * reise.getDauerPKW() + " Stunden"); System.out.println("Reisedauer Fahrrad: "
+		 * + reise.getDauerFahrrad() + " Stunden");
+		 * System.out.println("CO2-Ausstoß PKW: " + reise.berechneCO2Ausstoss() + " g");
+		 */
+	}
+
+	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();
+
+			switch (transportmittel) {
+			case "fahrrad":
+				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.getName() + " (PLZ: " + ort.getPLZ() + ")");
+					}
+				}
+				break;
+			case "auto":
+				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.getName() + " (PLZ: " + ort.getPLZ() + ")");
+					}
+				}
+				break;
+			default:
+				System.out.println("Ungültige Option. Bitte wählen Sie entweder 'Fahrrad' oder 'Auto'.");
+				break;
+			}
+		} 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/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().getOrtName());
+        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,3 @@
+dana,a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3,67105,Schifferstadt,audi,123.0,60.0,30.0
+max,a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3,555,berlin,audi,12.0,23.0,34.0
+tina,a665a45920422f9d417e4867efdc4fb8a04a1f3fff1fa07e998e86f7f7a27ae3,1328,Dresden,audi,12.0,34.0,56.0