Progress Bar

.gitignore

@@ -1,2 +1,5 @@
 out/
 conf.ini
+log/
+reports/
+.idea/dataSources*

.idea/libraries/com_google_code_gson_gson_2_8_6.xml

@@ -0,0 +1,10 @@
+<component name="libraryTable">
+  <library name="com.google.code.gson:gson:2.8.6" type="repository">
+    <properties maven-id="com.google.code.gson:gson:2.8.6" />
+    <CLASSES>
+      <root url="jar://$MAVEN_REPOSITORY$/com/google/code/gson/gson/2.8.6/gson-2.8.6.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/libraries/iText_4_2_0_com_itextpdf.xml

@@ -0,0 +1,9 @@
+<component name="libraryTable">
+  <library name="iText-4.2.0-com.itextpdf">
+    <CLASSES>
+      <root url="jar://$PROJECT_DIR$/lib/iText-4.2.0-com.itextpdf.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/libraries/org_apache_pdfbox_pdfbox_1_8_9.xml

@@ -0,0 +1,13 @@
+<component name="libraryTable">
+  <library name="org.apache.pdfbox:pdfbox:1.8.9" type="repository">
+    <properties maven-id="org.apache.pdfbox:pdfbox:1.8.9" />
+    <CLASSES>
+      <root url="jar://$MAVEN_REPOSITORY$/org/apache/pdfbox/pdfbox/1.8.9/pdfbox-1.8.9.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/apache/pdfbox/fontbox/1.8.9/fontbox-1.8.9.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/apache/pdfbox/jempbox/1.8.9/jempbox-1.8.9.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/commons-logging/commons-logging/1.1.1/commons-logging-1.1.1.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/libraries/org_postgresql_postgresql_42_2_19.xml

@@ -0,0 +1,11 @@
+<component name="libraryTable">
+  <library name="org.postgresql:postgresql:42.2.19" type="repository">
+    <properties maven-id="org.postgresql:postgresql:42.2.19" />
+    <CLASSES>
+      <root url="jar://$MAVEN_REPOSITORY$/org/postgresql/postgresql/42.2.19/postgresql-42.2.19.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/checkerframework/checker-qual/3.5.0/checker-qual-3.5.0.jar!/" />
+    </CLASSES>
+    <JAVADOC />
+    <SOURCES />
+  </library>
+</component>

.idea/sqldialects.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="SqlDialectMappings">
+    <file url="file://$PROJECT_DIR$/src/tourplaner/data/PostgresHelper.java" dialect="GenericSQL" />
+    <file url="PROJECT" dialect="PostgreSQL" />
+  </component>
+</project>

Tourplaner.iml

@@ -10,5 +10,9 @@
     <orderEntry type="library" name="lib" level="project" />
     <orderEntry type="library" name="org.ini4j:ini4j:0.5.4" level="project" />
     <orderEntry type="library" name="log4j:log4j:1.2.17" level="project" />
+    <orderEntry type="library" name="org.postgresql:postgresql:42.2.19" level="project" />
+    <orderEntry type="library" name="iText-4.2.0-com.itextpdf" level="project" />
+    <orderEntry type="library" name="org.json:json:20180130" level="project" />
+    <orderEntry type="library" name="com.google.code.gson:gson:2.8.6" level="project" />
   </component>
 </module>

TourplanerTabellen.sql

@@ -0,0 +1,20 @@
+// Tour Tabelle
+
+create table tour
+(
+	tourname varchar not null,
+	dauer decimal,
+	mapjson varchar,
+	start varchar,
+	ziel varchar,
+	strecke decimal
+);
+
+create unique index tour_tourname_uindex
+	on tour (tourname);
+
+alter table tour add constraint tour_pk primary key (tourname);
+
+#// Log Table
+
+create table log(tourname varchar constraint log_tour_tourname_fk references tour,id varchar,bemerkung varchar,datum date,strecke decimal,avg decimal,hightmeter decimal,pause decimal,gegangen decimal,dauer decimal);

conf.ini.sample

@@ -13,7 +13,17 @@ port = 5432
 user =
 pw =
 
+[report]
+path = ./reports/
+
 [hilfe]
 gitrepo = https://git.dergeorg.at/dergeorg/tourplaner
 doxygendoc = https://git.dergeorg.at/dergeorg/tourplaner
 javadoc = https://git.dergeorg.at/dergeorg/tourplaner
+
+[map]
+key =
+size = 1500,400
+sizePdf = 600,400
+path = D:\\TourplanerImages\\
+file_pre = file:///

langde.ini

@@ -34,3 +34,29 @@ logtournotselectedmsg = Bitte wählen Sie zuerst eine Tour aus, bevor sie einen
 keintextimfeld = Bitte tragen Sie einen Text in das Feld ein!
 nurzahlen = Bitte geben Sie nur Zahlen an!
 nurpositivezahlen = Bitte geben Sie nur positive Zahlen an!
+pause = Pause
+pausemsg = Dauer der Pause
+hightmeter = Höhenmeter
+hightmetermsg = Höhenmeter des Abschnitts
+bemerkung = Bemerkung
+bemerkungheader = Bitte geben Sie die Bemerkungen zu diesem Log eintrag ein, kann auch leer bleiben.
+tourreportvon = Tour Report von ->
+tourplanervon = Tourplaner by DerGeorg
+reportkeywords = Tourplaner, Tour, Report
+tourplaner = Tourplaner"
+tour = Tour
+reportvon = Report erstellt von:
+reportstart = Startpunkt der Tour:
+reportziel = Zielpunkt der Tour:
+reportdauercal = Berechnete Dauer der Tour:
+reportstreckecal = Berechnete Strecke der Tour:
+logs = Logs
+countlog = Anzahl der Logeinträge:
+logvom = Log vom:
+logdauer = Dauer:
+logpause = Davon Pause:
+loggegangen = Davon gegangen:
+logavg = Berechnete Durchschnittliche Geschwindigkeit:
+logstrecke = Entfernung:
+loghight = Höhenmeter:
+logbemerkung = Bemerkung:

log/log4j/log.out

@@ -1,13 +0,0 @@
-2021-03-18 22:41:23 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-18 22:48:51 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-18 22:53:17 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-18 22:57:20 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-18 22:57:28 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-18 22:58:33 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-18 22:58:34 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-18 23:05:00 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-18 23:11:45 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-18 23:14:55 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-19 11:56:22 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-19 22:35:19 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!
-2021-03-19 23:23:36 ERROR ViewModel -> DelTour:33 - Keine Tour ausgewählt!

src/tourplaner/Main.java

@@ -8,6 +8,7 @@ import javafx.scene.image.Image;
 import javafx.stage.Stage;
 
 import tourplaner.business.ConfigHelper;
+import tourplaner.business.TourPlaner;
 
 import java.io.IOException;
 
@@ -23,7 +24,8 @@ public class Main extends Application {
         Parent root  = FXMLLoader.load(Main.class.getResource("tourplaner.fxml"));
         primaryStage.setTitle(ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "start", "apptitle"));
         primaryStage.getIcons().add(new Image("file:"+ ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "start", "logo")));
-        primaryStage.setScene(new Scene(root, 600, 600));
+        TourPlaner.init();
+        primaryStage.setScene(new Scene(root, 1500, 1000));
         primaryStage.show();
     }
 }

src/tourplaner/business/DirectionMap.java

@@ -0,0 +1,89 @@
+package tourplaner.business;
+
+import java.awt.*;
+import java.io.File;
+import java.io.IOException;
+
+/**
+ * Zuständig für das besorgen der Map für die UI und PDF-Reports und für die Berechneten infos der Tour (Dauer, Strecke)
+ */
+public class DirectionMap {
+    private double dauer, strecke;
+    private String start, end, tourname, file, filepdf;
+    private Image map, mappdf;
+
+    /**
+     * Holt die Map als image und alle Daten zur berechneten Route
+     *
+     * @param start Startpunkt
+     * @param ende Endpunkt
+     * @param tourname Name der Aktuellen Tour
+     * @throws IOException Fehler beim Image der Map
+     */
+    public DirectionMap (String start, String ende, String tourname) throws IOException {
+        this.map = getMap(start, ende, ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "map", "size"));
+        this.mappdf = getMap(start, ende, ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "map", "sizePdf"));
+        this.start = start;
+        this.end = ende;
+        this.tourname = tourname;
+        this.file = ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "map", "path") + this.tourname + ".jpg";
+        this.filepdf = ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "map", "path") + this.tourname + "_pdf.jpg";
+        FileHelper.saveImage(this.map, "jpg", new File(this.file));
+        FileHelper.saveImage(this.mappdf, "jpg", new File(this.filepdf));
+        getDirections(start, ende);
+        FileHelper.openDefault(file);
+    }
+
+    /**
+     * Get berechnete Dauer in Minuten
+     * @return Berechnete Dauer der Tour
+     */
+    public double getDauer() {
+        return dauer;
+    }
+
+    /**
+     * Get berechnete Strecke
+     * @return Berechnete Strecke der Tour
+     */
+    public double getStrecke() {
+        return strecke;
+    }
+
+    /**
+     * Downloadet die Map von Mapquest
+     * @param start Startpunkt
+     * @param ende Endpunkt
+     * @return Image von der Map
+     * @throws IOException Fehler beim Get der Map
+     */
+    private Image getMap(String start, String ende, String size) throws IOException {
+        return HttpHelper.httpGetImage("https://www.mapquestapi.com/staticmap/v5/map?start="+start+"&end="+ende+"&size="+size+"&key="+ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "map", "key"));
+    }
+
+    /**
+     * Besorgt die Infos der Tour von Mapquest Directions
+     * @param start Start der Tour
+     * @param ende Ende der Tour
+     * @throws IOException Fehler beim besorgen der infos über die Tour
+     */
+    private void getDirections(String start, String ende) throws IOException {
+        String json = HttpHelper.httpGetJsonString("https://www.mapquestapi.com/directions/v2/route?key="+ ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "map", "key")+"&from="+start+"&to="+ende+"&outFormat=json&ambiguities=ignore&routeType=fastest&doReverseGeocode=false&enhancedNarrative=false&avoidTimedConditions=false");
+        this.strecke = JsonHelper.getDoubleFromJson(json, "distance");
+        this.dauer = formatetTimeToMinutes(JsonHelper.getStingFromJson(json, "formattedTime"));
+    }
+
+    /**
+     * Formatet time HH:MM:SS in Minuten umwandeln
+     * @param formatetTime Formatet time HH:MM:SS
+     * @return Zeit in Minuten
+     */
+    private double formatetTimeToMinutes(String formatetTime){
+        double minutes = 0;
+        String[] result = formatetTime.split(":");
+        minutes += Double.parseDouble(result[0]) * 60;
+        minutes += Double.parseDouble(result[1]);
+        minutes += Double.parseDouble(result[2]) / 60;
+        return minutes;
+    }
+}

src/tourplaner/business/Exporter.java

@@ -0,0 +1,72 @@
+package tourplaner.business;
+
+import tourplaner.data.DbConnect;
+import tourplaner.object.Log;
+import tourplaner.object.Tour;
+import tourplaner.ui.AlertHelper;
+import tourplaner.ui.ProgressBar;
+
+import javax.swing.*;
+import java.io.*;
+import java.util.ArrayList;
+
+/**
+ * Ist für das importieren und Exportieren der Daten zuständig
+ */
+public class Exporter {
+
+    private ArrayList<Tour> touren;
+    private String path;
+
+    /**
+     * Erstellt den Exporter mit dem gegebenen Path
+     * @param path Gegebener Path
+     */
+    public Exporter(String path) {
+        this.path = path;
+    }
+
+    /**
+     * Führt den Export aus -> Holt daten, erstellt file
+     * @throws IOException Fehler beim File erstellen
+     */
+    public void doExport() throws IOException {
+        ProgressBar progressBar = new ProgressBar("Exportieren");
+        int step = progressBar.getProgressSize(4, 100);
+        ArrayList<Tour> data = new DbConnect().getAllTouren();
+        progressBar.addProgress(step);
+        FileWriter fileWriter = new FileWriter(path + ".json");
+        progressBar.addProgress(step);
+        JsonHelper.getJsonFromObj(data, fileWriter);
+        progressBar.addProgress(step);
+        BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
+        progressBar.addProgress(step);
+        bufferedWriter.close();
+    }
+
+    /**
+     * Führt den Imput aus -> File holen, Daten in db erstellen
+     * @throws IOException Fehler beim File öffnen
+     */
+    public void doImport() throws IOException {
+        this.touren = JsonHelper.getTourenFromJson(new FileReader(this.path));
+        ProgressBar progressBar = new ProgressBar("Importiere Daten");
+        DbConnect dbConnect = new DbConnect();
+        progressBar.addProgress(5);
+        dbConnect.delAllData();
+        progressBar.addProgress(5);
+        int size = progressBar.getProgressSize(this.touren.size() * 3, 100);
+        for (Tour tour:this.touren) {
+            new DirectionMap(tour.getStart(), tour.getZiel(), tour.getName());
+            progressBar.addProgress(size);
+            dbConnect.addTour(tour);
+            progressBar.addProgress(size);
+            ArrayList<Log> logs = tour.getLogs();
+            for (Log log:logs) {
+                dbConnect.addLog(tour.getName(), log);
+            }
+            progressBar.addProgress(size);
+        }
+        progressBar.addProgress(size);
+    }
+}

src/tourplaner/business/FileHelper.java

@@ -0,0 +1,62 @@
+package tourplaner.business;
+
+import javax.imageio.ImageIO;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+
+public class FileHelper {
+
+    /**
+     * Öffnet ein File mit dem Standart Program
+     * @param f File Path als string
+     */
+    public static void openDefault(String f){
+        // A reference to a text file
+        File file = new File(f);
+
+        try {
+            Desktop desktop = Desktop.getDesktop();
+
+            // Open a file using the default program for the file type. In the example
+            // we will launch a default registered program to open a text file. For
+            // example on Windows operating system this call might launch a notepad.exe
+            // to open the file.
+            desktop.open(file);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Speichert ein Image
+     * @param img Das zu speichernde Bild
+     * @param type Dateityp z.b. jpg
+     * @param file Wo die datei zu speichern ist
+     * @throws IOException
+     */
+    public static void saveImage(Image img, String type, File file) throws IOException {
+        ImageIO.write(ImgHelper.toBufferedImage(img), type, file);
+    }
+
+    /**
+     * Holt ein image von einem File
+     * @param file File mit dem image
+     * @return Das buffered image
+     * @throws IOException Fehler beim öffnen des bildes
+     */
+    public static BufferedImage getImage(File file) throws IOException {
+        return ImageIO.read(file);
+    }
+
+    /**
+     * Löscht ein File
+     * @param file File das zu löschen ist
+      * @return false bei error
+     */
+    public static boolean delFile(File file){
+        return file.delete();
+    }
+}

src/tourplaner/business/HttpHelper.java

@@ -0,0 +1,53 @@
+package tourplaner.business;
+
+import javax.imageio.ImageIO;
+import java.awt.*;
+import java.io.*;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+/**
+ * Http Hilfsfunktionen
+ */
+public class HttpHelper {
+
+    /**
+     * Holt ein Image von gegebener URL
+     * @param url Url als Sting
+     * @return Image von der Url
+     * @throws IOException Fehler beim Bild holen
+     */
+    public static Image httpGetImage(String url) throws IOException {
+        URL urls = new URL(url);
+        return ImageIO.read(urls);
+    }
+
+    /**
+     * Http GET Json string vom Url string
+     * @param url Url als String
+     * @return Json als String
+     * @throws IOException Fehler beim Json holen
+     */
+    public static String httpGetJsonString(String url) throws IOException {
+        HttpURLConnection con = null;
+        try {
+            var myurl = new URL(url);
+            con = (HttpURLConnection) myurl.openConnection();
+            con.setRequestMethod("GET");
+            StringBuilder content;
+            try (BufferedReader in = new BufferedReader(
+                    new InputStreamReader(con.getInputStream()))) {
+                String line;
+                content = new StringBuilder();
+                while ((line = in.readLine()) != null) {
+                    content.append(line);
+                    content.append(System.lineSeparator());
+                }
+            }
+            return content.toString();
+        } finally {
+            assert con != null;
+            con.disconnect();
+        }
+    }
+}

src/tourplaner/business/ImgHelper.java

@@ -0,0 +1,35 @@
+package tourplaner.business;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+
+/**
+ * Image Hilfsfunktionen
+ */
+public class ImgHelper {
+
+    /**
+     * Converts a given Image into a BufferedImage
+     *
+     * @param img The Image to be converted
+     * @return The converted BufferedImage
+     */
+    public static BufferedImage toBufferedImage(Image img)
+    {
+        if (img instanceof BufferedImage)
+        {
+            return (BufferedImage) img;
+        }
+
+        // Create a buffered image with transparency
+        BufferedImage bimage = new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_ARGB);
+
+        // Draw the image on to the buffered image
+        Graphics2D bGr = bimage.createGraphics();
+        bGr.drawImage(img, 0, 0, null);
+        bGr.dispose();
+
+        // Return the buffered image
+        return bimage;
+    }
+}

src/tourplaner/business/JsonHelper.java

@@ -0,0 +1,72 @@
+package tourplaner.business;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.gson.reflect.TypeToken;
+import tourplaner.object.Tour;
+
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.util.ArrayList;
+
+/**
+ * Hilfsklasse für Json (Gson)
+ */
+public class JsonHelper {
+
+    /**
+     * String aus json extrahieren
+     * @param json Json als String
+     * @param gets Eintrag im Json unter "route"
+     * @return Gesammelter String
+     */
+    public static String getStingFromJson(String json, String gets){
+        return getJObj(json).get("route").getAsJsonObject().get(gets).getAsString();
+    }
+
+    /**
+     * Double aus json extrahieren
+     * @param json Json als String
+     * @param gets Eintrag im Json unter "route"
+     * @return Gesammelter Double Wert
+     */
+    public static double getDoubleFromJson(String json, String gets){
+        return getJObj(json).get("route").getAsJsonObject().get(gets).getAsDouble();
+    }
+
+    /**
+     * Erzeugt ein Json aus einem Object
+     * @param obj Das Objekt
+     * @return Json des Objektes
+     */
+    public static String getJsonFromObj(Object obj){
+        return new Gson().toJson(obj);
+    }
+
+    /**
+     * Erzeugt ein Json aus einem Object
+     * @param obj Das Objekt
+     * @param writer File in das geschrieben werden soll
+     */
+    public static void getJsonFromObj(Object obj , FileWriter writer){
+        new Gson().toJson(obj, writer);
+    }
+
+    /**
+     * Wandelt ein Json file in ein Data Objekt um
+     * @param reader File aus dem gelesen wird
+     * @return Data objekt das gelesen wurde
+     */
+    public static ArrayList<Tour> getTourenFromJson(FileReader reader){
+        return new Gson().fromJson(reader, new TypeToken<ArrayList<Tour>>() {}.getType());
+    }
+
+    /**
+     * Json String to JsonObject
+     * @param json Json string
+     * @return Neues JsonObject aus String
+     */
+    private static JsonObject getJObj(String json){
+       return new Gson().fromJson(json, JsonObject.class);
+    }
+}

src/tourplaner/business/LogHelper.java

@@ -33,6 +33,14 @@ public class LogHelper{
         getLog(name).error(msg);
     }
 
+    /**
+     * Log info in file und Console
+     * @param e Exception
+     */
+    public static void error(Exception e){
+        getLog(e.getClass().getName()).error(e.getMessage());
+    }
+
     /**
      * Log info in file und Console
      * @param msg Nachricht in dem Log

src/tourplaner/business/Reporter.java

@@ -0,0 +1,243 @@
+package tourplaner.business;
+
+import com.itextpdf.text.*;
+import com.itextpdf.text.Font;
+import com.itextpdf.text.Image;
+import tourplaner.data.DbConnect;
+import tourplaner.object.Log;
+import tourplaner.object.Tour;
+
+import com.itextpdf.text.pdf.PdfPCell;
+import com.itextpdf.text.pdf.PdfPTable;
+import com.itextpdf.text.pdf.PdfWriter;
+
+import java.awt.*;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Date;
+
+/**
+ * PDF Report generierung mit iText
+ *
+ * Erstellt Reports über einzelne Touren und fasst alle Touren zusammen
+ *
+ * iText 4 ist gratis verfügbar, siehe:
+ * https://github.com/ymasory/iText-4.2.0
+ */
+public class Reporter {
+
+    private static Font catFont = new Font(Font.TIMES_ROMAN, 18,
+            Font.BOLD);
+    private static Font redFont = new Font(Font.TIMES_ROMAN, 12,
+            Font.NORMAL, Color.RED);
+    private static Font subFont = new Font(Font.TIMES_ROMAN, 16,
+            Font.BOLD);
+    private static Font smallBold = new Font(Font.TIMES_ROMAN, 12,
+            Font.BOLD);
+
+    /**
+     * Erstellt den Summary Report
+     */
+    public static void sumReport(){
+        ArrayList<Tour> tours = TourPlaner.getAllTours();
+        String file = ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "report", "path") + "summary.pdf";
+        try {
+            Document document = new Document();
+            PdfWriter.getInstance(document, new FileOutputStream(file));
+            document.open();
+            addSumRepo(document, tours);
+
+            document.close();
+        } catch (DocumentException | FileNotFoundException e) {
+            LogHelper.error(e.getMessage(), e.getClass().getName());
+        }
+        FileHelper.openDefault(file);
+    }
+
+    /**
+     * Content des Sumary reports
+     * @param document Document auf das geschrieben wird
+     * @param touren Touren die berechnet werden
+     * @throws DocumentException Fehler beim schreiben auf das Dokument
+     */
+    private static void addSumRepo(Document document, ArrayList<Tour> touren) throws DocumentException {
+        double dauer = 0;
+        double strecke = 0;
+        double calDauer = 0;
+        double calStecke = 0;
+        for (Tour tour:touren) {
+            calStecke += tour.getStrecke();
+            calDauer += Double.parseDouble(tour.getDauer());
+            ArrayList<Log> logs = tour.getLogs();
+            for (Log log:logs) {
+                dauer += log.getDauer();
+                strecke += log.getStrecke();
+            }
+        }
+        Anchor anchor = new Anchor("Zusammengefasster Report", catFont);
+        anchor.setName("Zusammengefasster Report");
+        // Second parameter is the number of the chapter
+        Chapter catPart = new Chapter(new Paragraph(anchor), 1);
+        Paragraph subPara = new Paragraph("Daten", subFont);
+        Section subCatPart = catPart.addSection(subPara);
+        subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("reportvon") + System.getProperty("user.name") + ", " + new Date()));
+        subCatPart.add(new Paragraph("Gesammte Zeit aller Logs: " + dauer));
+        subCatPart.add(new Paragraph("gesammte Strecke aller Logs: " + strecke));
+        subCatPart.add(new Paragraph("Berechnete Zeit aller Logs: " + calDauer));
+        subCatPart.add(new Paragraph("Berechnete Strecke aller Touren: " + calStecke));
+        document.add(catPart);
+    }
+
+    /**
+     * Erstellt einen Tour Report
+     * @param tourname Name der Tour die Gereportet werden soll
+     */
+    public static void createTourReport(String tourname)   {
+        Tour tour = TourPlaner.getTour(tourname);
+        tour.setLog(TourPlaner.getLogs(tourname));
+        String file = ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "report", "path") + tourname+".pdf";
+        try {
+            Document document = new Document();
+            PdfWriter.getInstance(document, new FileOutputStream(file));
+            document.open();
+            addMetaData(document, tour);
+//            addTitlePage(document, tour);
+            addContent(document, tour);
+            document.close();
+        } catch (DocumentException | FileNotFoundException e) {
+            LogHelper.error(e.getMessage(), e.getClass().getName());
+        }
+        FileHelper.openDefault(file);
+    }
+
+    // iText allows to add metadata to the PDF which can be viewed in your Adobe
+    // Reader
+    // under File -> Properties
+    private static void addMetaData(Document document, Tour tour) {
+        document.addTitle(ConfigHelper.getLangIniString("tourreportvon") + tour.getName());
+        document.addSubject(ConfigHelper.getLangIniString("tourplanervon"));
+        document.addKeywords(ConfigHelper.getLangIniString("reportkeywords"));
+        document.addAuthor(ConfigHelper.getLangIniString("tourplaner"));
+        document.addCreator(ConfigHelper.getLangIniString("tourplaner"));
+    }
+
+    /**
+     * Erstellt den inhalt des Reports
+     * @param document Aktuelles Dokument
+     * @param tour Aktuelle Tour
+     * @throws DocumentException Fehler beim hinzufügen des Inhaltes
+     */
+    private static void addContent(Document document, Tour tour) throws DocumentException {
+        Anchor anchor = new Anchor(ConfigHelper.getLangIniString("tourreportvon") + tour.getName(), catFont);
+        anchor.setName(ConfigHelper.getLangIniString("tourreportvon") + tour.getName());
+
+        // Second parameter is the number of the chapter
+        Chapter catPart = new Chapter(new Paragraph(anchor), 1);
+
+        Paragraph subPara = new Paragraph(ConfigHelper.getLangIniString("tour"), subFont);
+        Section subCatPart = catPart.addSection(subPara);
+        subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("reportvon") + System.getProperty("user.name") + ", " + new Date()));
+        subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("reportstart") + tour.getStart()));
+        subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("reportziel") + tour.getZiel()));
+        subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("reportdauercal") + tour.getDauer()));
+        subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("reportstreckecal") + tour.getStrecke()));
+        Paragraph emptyLine = new Paragraph();
+        addEmptyLine(emptyLine, 5);
+        subCatPart.add(emptyLine);
+        // now add all this to the document
+        document.add(catPart);
+
+        Image image1 = null;
+        try {
+            image1 = Image.getInstance(TourPlaner.getImagePdfPath(tour.getName()));
+            image1.setAlignment(Element.ALIGN_CENTER);
+            image1.scaleAbsolute(600, 400);
+
+            document.add(image1);
+        } catch (IOException e) {
+            LogHelper.error(e);
+        }
+        ArrayList<Log> logs = tour.getLogs();
+        // Second parameter is the number of the chapter
+        anchor = new Anchor(ConfigHelper.getLangIniString("logs"), catFont);
+        anchor.setName(ConfigHelper.getLangIniString("logs"));
+        catPart = new Chapter(new Paragraph(anchor), 2);
+        catPart.add(new Paragraph(ConfigHelper.getLangIniString("countlog") + logs.size()));
+
+        for (Log log: logs) {
+            subPara = new Paragraph(ConfigHelper.getLangIniString("logvom") + log.getDatum() , subFont);
+            subCatPart = catPart.addSection(subPara);
+            subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("logdauer") + log.getDauer()));
+            subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("logpause") + log.getPause()));
+            subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("loggegangen") + log.getGegangen()));
+            subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("logavg")+ log.getAvgspeed()));
+            subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("logstrecke") + log.getStrecke()));
+            subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("loghight") + log.getHightmeter()));
+            subCatPart.add(new Paragraph(ConfigHelper.getLangIniString("logbemerkung") + log.getBemerkung()));
+        }
+        // now add all this to the document
+        document.add(catPart);
+    }
+
+    /**
+     * Fügt eine leere zeile an den Paragraph an
+     * @param paragraph Hier wird hinzugefügt
+     * @param number Um wie viele Leere Zeilen hinzugefügt werden soll
+     */
+    private static void addEmptyLine(Paragraph paragraph, int number) {
+        for (int i = 0; i < number; i++) {
+            paragraph.add(new Paragraph(" "));
+        }
+    }
+//    private static void createTable(Section subCatPart)
+//            throws BadElementException {
+//        PdfPTable table = new PdfPTable(5);
+//
+//        // t.setBorderColor(BaseColor.GRAY);
+//        // t.setPadding(4);
+//        // t.setSpacing(4);
+//        // t.setBorderWidth(1);
+//
+//        PdfPCell c1 = new PdfPCell(new Phrase("NR"));
+//        c1.setHorizontalAlignment(Element.ALIGN_CENTER);
+//        table.addCell(c1);
+//
+//        c1 = new PdfPCell(new Phrase("Datum"));
+//        c1.setHorizontalAlignment(Element.ALIGN_CENTER);
+//        table.addCell(c1);
+//
+//        c1 = new PdfPCell(new Phrase("Entfernung"));
+//        c1.setHorizontalAlignment(Element.ALIGN_CENTER);
+//        table.addCell(c1);
+//
+//        c1 = new PdfPCell(new Phrase("Höhenmeter"));
+//        c1.setHorizontalAlignment(Element.ALIGN_CENTER);
+//        table.addCell(c1);
+//
+//        c1 = new PdfPCell(new Phrase("AVG Geschwindigkeit"));
+//        c1.setHorizontalAlignment(Element.ALIGN_CENTER);
+//        table.addCell(c1);
+//
+//
+//        table.setHeaderRows(1);
+//
+//        table.addCell("1.0");
+//        table.addCell("1.1");
+//        table.addCell("1.2");
+//        table.addCell("1.3");
+//        table.addCell("1.4");
+//        table.addCell("1.5");
+//
+//        table.addCell("2.0");
+//        table.addCell("2.1");
+//        table.addCell("2.2");
+//        table.addCell("2.3");
+//        table.addCell("2.4");
+//        table.addCell("2.5");
+//
+//        subCatPart.add(table);
+//
+//    }
+}

src/tourplaner/business/TourPlaner.java

@@ -2,6 +2,14 @@ package tourplaner.business;
 
 import org.apache.log4j.Logger;
 import tourplaner.data.DbConnect;
+import tourplaner.object.Log;
+import tourplaner.object.Tour;
+
+import java.awt.*;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
 
 /**
  * Haupt Logik des Tourplaners
@@ -9,14 +17,177 @@ import tourplaner.data.DbConnect;
 public class TourPlaner{
     private Logger logger;
 
-    public TourPlaner(){
+    /**
-        LogHelper.info(ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "start", "message"),
+     * Erstellt alle DB Tabellen falls nötig
-                ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "start", "app"));
+     */
+    public static void init(){
         new DbConnect().init();
-
     }
 
-    public String getMapJson(String start, String ziel){
+    /**
-        return start + " " + ziel;
+     * Holt alle touren aus der DB 
+     * @return Alle touren als ArrayList
+     */
+    public static ArrayList<Tour> getAllTours(){
+        return new DbConnect().getAllTouren();
     }
+
+    /**
+     * Bearbeitet eine Tour
+     * @param oldname Alter Tourname
+     * @param tour Neuer Tourname
+     * @return false bei error
+     */
+    public static boolean editTour(String oldname, Tour tour) throws IOException {
+        FileHelper.delFile(new File(getImagePath(oldname)));
+        FileHelper.delFile(new File(getImagePdfPath(oldname)));
+        DirectionMap directionMap = new DirectionMap(tour.getStart(), tour.getZiel(), tour.getName());
+        tour.setDauer(directionMap.getDauer()+"");
+        tour.setStrecke(directionMap.getStrecke());
+        return new DbConnect().editTour(oldname, tour);
+    }
+
+    /**
+     * Löscht eine Tour
+     * @param tourname Tourname
+     * @return false bei error
+     */
+    public static boolean delTour(String tourname){
+        FileHelper.delFile(new File(getImagePath(tourname)));
+        FileHelper.delFile(new File(getImagePdfPath(tourname)));
+        return new DbConnect().delTour(tourname);
+    }
+    /**
+     * Fügt eine Tour hinzu
+     * @param newTour Neue Tour
+     * @return false bei error
+     */
+    public static boolean addTour(Tour newTour) throws IOException {
+        DirectionMap directionMap = new DirectionMap(newTour.getStart(), newTour.getZiel(), newTour.getName());
+        newTour.setDauer(directionMap.getDauer()+"");
+        newTour.setStrecke(directionMap.getStrecke());
+        return new DbConnect().addTour(newTour);
+    }
+
+    /**
+     * Holt das Gui Bild
+     * @param tourname Name der Tour
+     * @return Das Bild
+     * @throws IOException Error beim Bild holen
+     */
+    public static Image getImage(String tourname) throws IOException {
+        return FileHelper.getImage(new File(getImagePath(tourname)));
+    }
+
+     /**
+     * Path zu dem Bild für die GUI
+     * @param tourname Name der Tour
+     * @return Path zu dem Bild für die GUI
+     */
+    public static String getImagePath(String tourname){
+        return ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "map", "path") + tourname + ".jpg";
+    }
+
+    /**
+     * Path zu dem Bild für die PDF
+     * @param tourname Name der Tour
+     * @return Path zu dem Bild für die PDF
+     */
+    public static String getImagePdfPath(String tourname){
+        return ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "map", "path") + tourname + "_pdf.jpg";
+    }
+
+    /**
+     * Öffnet ein Bild einer Tour
+     * @param tourname Tourname
+     */
+    public static void openImage(String tourname){
+        FileHelper.openDefault(getImagePath(tourname));
+    }
+
+
+    /**
+     * Holt alle Logs einer Tour
+     * @param tourname Tourname
+     * @return Alle Logs der Tour
+     */
+    public static ArrayList<Log> getLogs(String tourname){
+        return new DbConnect().getLogs(tourname);
+    }
+
+    /**
+     * Führt einen Rport aus
+     * @param tourname Name der Tour die gereportet wird
+     */
+    public static void doReport(String tourname){
+        Reporter.createTourReport(tourname);
+    }
+
+    /**
+     * Holt eine Tour
+     * @param tourname Name der zu holenden Tour
+     * @return Tour die geholt werden soll
+     */
+    public static Tour getTour(String tourname){
+        return new DbConnect().getTour(tourname);
+    }
+
+    /**
+     * Fügt ein Log hinzu
+     * @param tourname Name der Tour
+     * @param log Neues Log
+     * @return false bei error
+     */
+    public static boolean addLog(String tourname, Log log){
+        if(Double.isInfinite(log.getAvgspeed())) log.setAvgspeed(-1.0);
+        return new DbConnect().addLog(tourname, log);
+    }
+
+    /**
+     * Löscht ein Log
+     * @param tourname Name der Tour
+     * @param id Id des Logs
+     * @return false bei error
+     */
+    public static boolean delLog(String tourname, String id){
+        return new DbConnect().delLog(tourname, id);
+    }
+
+    /**
+     * Editiert ein Log
+     * @param tourname Name der Tour
+     * @param log Neues Log
+     * @return false bei error
+     */
+    public static boolean editLog(String tourname, Log log){
+        if(Double.isInfinite(log.getAvgspeed())) log.setAvgspeed(-1.0);
+        return new DbConnect().editLog(tourname, log);
+    }
+
+    /**
+     * Exportiert die Daten
+     * @param path Path zu den Daten
+     * @throws IOException Fehler beim schreiben der Daten
+     */
+    public static void exportData(String path) throws IOException {
+            Exporter exporter = new Exporter(path);
+            exporter.doExport();
+            FileHelper.openDefault(path);
+    }
+
+    /**
+     * Sucht alle touren die den gegebenen tournamen enthalten
+     * @param tourname Name der zu suchen ist
+     * @return Alle touren die auf den Suchterm passen
+     */
+    public static ArrayList<Tour> sucheTour(String tourname){
+        ArrayList<Tour> touren = new ArrayList<>();
+        getAllTours().forEach(t ->{
+            if(t.getName().contains(tourname)){
+                touren.add(t);
+            }
+        });
+        return touren;
+    }
+
 }

src/tourplaner/data/DbConnect.java

@@ -1,7 +1,14 @@
 package tourplaner.data;
 
+import javafx.geometry.Pos;
+import tourplaner.object.Log;
+import tourplaner.object.Tour;
+
 import java.sql.Connection;
+import java.sql.Date;
+import java.sql.ResultSet;
 import java.sql.Statement;
+import java.time.LocalDate;
 import java.util.ArrayList;
 
 /**
@@ -26,10 +33,203 @@ public class DbConnect {
      * @return True bei erfolg, sonst error
      */
     public boolean init() {
-        // TODO: 26.02.2021 Alle sql im init sind noch falsch
         ArrayList<Boolean> errors = new ArrayList<>();
-        errors.add(PostgresHelper.executeUpdateMessage("CREATE TABLE IF NOT EXISTS USERS (username TEXT PRIMARY KEY NOT NULL, nachname TEXT NOT NULL, email TEXT NOT NULL, password TEXT NOT NULL, bio TEXT, image TEXT, coins integer default 20 not null)", "User Table created"));
+        errors.add(PostgresHelper.executeUpdateMessage("create table tour ( tourname varchar not null, dauer decimal, mapjson varchar, start varchar, ziel varchar, strecke decimal);", "Tour Table created"));
+        errors.add(PostgresHelper.executeUpdateMessage("create unique index tour_tourname_uindex on tour (tourname);", "Tour Table unique created"));
+        errors.add(PostgresHelper.executeUpdateMessage("alter table tour add constraint tour_pk primary key (tourname);", "Tour Table primary created"));
+        errors.add(PostgresHelper.executeUpdateMessage("create table log(tourname varchar constraint log_tour_tourname_fk references tour,id varchar,bemerkung varchar,datum date,strecke decimal,avg decimal,hightmeter decimal,pause decimal,gegangen decimal,dauer decimal);", "Log Table created"));
         return !errors.contains(false);
     }
 
+
+    /**
+     * Bearbeitet eine Tour
+     * @param oldname Alter Tour name
+     * @param tour Neues Tour Object
+     * @return false bei error
+     */
+    public boolean editTour(String oldname, Tour tour) {
+        String tourname = tour.getName();
+        ArrayList<Boolean> result = new ArrayList<>();
+        ArrayList<Log> logs = getLogs(oldname);
+        result.add(delLogs(oldname));
+        result.add(PostgresHelper.executeUpdate("UPDATE public.tour SET tourname = '"+tour.getName()+"', dauer = 1, mapjson = '"+tour.getMapJson()+"', start = '"+tour.getStart()+"', ziel = '"+tour.getZiel()+"', strecke = "+tour.getStrecke()+" WHERE tourname ='" + oldname + "';"));
+        logs.forEach(log -> {
+            result.add(addLog(tourname, log));
+        });
+        return !result.contains(false);
+    }
+
+    private boolean delLogs(String tourname){
+        return PostgresHelper.executeUpdate("DELETE FROM public.log WHERE tourname = '"+tourname+"'");
+    }
+    /**
+     * Fügt eine Tour hinzu
+     * @param tour Neue Tour
+     * @return false bei error
+     */
+    public boolean addTour(Tour tour){
+        return PostgresHelper.executeUpdate("INSERT INTO public.tour (tourname, dauer, mapjson, start, ziel, strecke) VALUES ('"+tour.getName()+"', "+tour.getDauer()+", '"+tour.getMapJson()+"', '"+tour.getStart()+"', '"+tour.getZiel()+"', "+tour.getStrecke()+")");
+    }
+
+    /**
+     * Löscht eine Tour anhand des Tournamens
+     * @param tourname Tourname der zu löschen ist
+     * @return false bei error
+     */
+    public boolean delTour(String tourname){
+        ArrayList<Boolean> result = new ArrayList<>();
+        result.add(delLogs(tourname));
+        result.add(PostgresHelper.executeUpdate("DELETE FROM public.tour WHERE tourname = '"+tourname+"'"));
+        return !result.contains(false);
+    }
+
+    public boolean delAllData(){
+        ArrayList<Boolean> result = new ArrayList<>();
+        result.add(delAllLog());
+        result.add(delAllTour());
+        return !result.contains(false);
+    }
+
+    private boolean delAllTour(){
+        return PostgresHelper.executeUpdate("DELETE FROM public.tour");
+    }
+
+    private boolean delAllLog(){
+        return  PostgresHelper.executeUpdate("DELETE FROM public.log");
+    }
+
+    public ArrayList<Log> getLogs(String tourname){
+
+        this.c = PostgresHelper.con();
+        String id, bemerkung ;
+        double dauer, strecke, pause, gegangen, avg, hightmeter;
+        Date datum;
+
+        ArrayList<Log> logs = new ArrayList<>();
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("SELECT * FROM public.log where tourname = '"+ tourname +"'");
+            while (rs.next()) {
+                id = rs.getString("id");
+                bemerkung = rs.getString("bemerkung");
+                datum = rs.getDate("datum");
+                dauer = rs.getDouble("dauer");
+//                avg = rs.getDouble("avg");
+                hightmeter = rs.getDouble("hightmeter");
+                pause = rs.getDouble("pause");
+//                gegangen = rs.getDouble("gegangen");
+                strecke = rs.getDouble("strecke");
+                if (!tourname.isEmpty()) {
+                    logs.add(new Log(id, dauer, datum.toLocalDate(), strecke, bemerkung,hightmeter, pause));
+                }else {
+                    return null;
+                }
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+            return logs;
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+    }
+
+
+    /**
+     * Füght einen Logeintrag ein
+     * @param tourname Zu welcher Tour der Logeintrag gehört
+     * @param log Der Logeintrag
+     * @return false bei error
+     */
+    public boolean addLog(String tourname, Log log){
+        if(Double.isInfinite(log.getAvgspeed())) log.setAvgspeed(-1.0);
+        return PostgresHelper.executeUpdate("INSERT INTO public.log (tourname, id, bemerkung, datum, strecke, avg, hightmeter, pause, gegangen, dauer) VALUES ('"+tourname+"', '"+log.getId()+"', '"+log.getBemerkung()+"', '"+log.getDatum()+"', "
+                +log.getStrecke()+", "+log.getAvgspeed()+", "+log.getHightmeter()+", "+log.getPause()+", "+log.getGegangen()+", "+log.getDauer()+")");
+    }
+
+    public boolean editLog(String tourname, Log log){
+        return PostgresHelper.executeUpdate("UPDATE public.log SET bemerkung = '"+log.getBemerkung()+"', datum = '"+log.getDatum()+"', strecke = "+log.getStrecke()+", avg = "+log.getAvgspeed()+", hightmeter = "+
+                log.getHightmeter()+", pause = "+log.getPause()+", gegangen = "+log.getGegangen()+", dauer = "+log.getDauer()+" WHERE tourname = '"+tourname+"' and id = '"+log.getId()+"'");
+    }
+
+    public boolean delLog(String tourname, String id){
+        System.out.println("DELETE FROM public.log WHERE tourname = '"+tourname+"' and id = '"+id+"'");
+        return PostgresHelper.executeUpdate("DELETE FROM public.log WHERE tourname = '"+tourname+"' and id = '"+id+"'");
+    }
+
+    /**
+     * Holt alle Touren aus der Datenbank
+     * @return Null bei fehler, sonst eine List aus den IDs
+     */
+    public ArrayList<Tour> getAllTouren(){
+        this.c = PostgresHelper.con();
+        String tourname, mapjson, start, ziel;
+        double dauer, strecke;
+
+        ArrayList<Tour> touren = new ArrayList<>();
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from tour;");
+            while (rs.next()) {
+                tourname = rs.getString("tourname");
+                mapjson = rs.getString("mapjson");
+                start = rs.getString("start");
+                ziel = rs.getString("ziel");
+                dauer = rs.getDouble("dauer");
+                strecke = rs.getDouble("strecke");
+                if (!tourname.isEmpty()) {
+                    touren.add(new Tour(tourname, dauer + "", mapjson, strecke, start, ziel, getLogs(tourname)));
+                }else {
+                    return null;
+                }
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+            return touren;
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * Holt eine Tour aus der Datenbank
+     * @param tn Tourname
+     * @return Null bei fehler, sonst eine List aus den IDs
+     */
+    public Tour getTour(String tn){
+        this.c = PostgresHelper.con();
+        String tourname, mapjson, start, ziel;
+        double dauer, strecke;
+
+        Tour touren = null;
+        try {
+            stmt = this.c.createStatement();
+            ResultSet rs = stmt.executeQuery("select * from tour where tourname = '"+tn+"';");
+            while (rs.next()) {
+                tourname = rs.getString("tourname");
+                mapjson = rs.getString("mapjson");
+                start = rs.getString("start");
+                ziel = rs.getString("ziel");
+                dauer = rs.getDouble("dauer");
+                strecke = rs.getDouble("strecke");
+                if (!tourname.isEmpty()) {
+                    touren = new Tour(tourname, dauer + "", mapjson, strecke, start, ziel);
+                }else {
+                    return null;
+                }
+            }
+            rs.close();
+            stmt.close();
+            this.c.close();
+            return touren;
+        } catch (Exception e) {
+            System.err.println(e.getClass().getName() + ": " + e.getMessage());
+            return null;
+        }
+    }
+
 }

src/tourplaner/data/PostgresHelper.java

@@ -3,16 +3,20 @@ package tourplaner.data;
 
 import tourplaner.business.ConfigHelper;
 import tourplaner.business.LogHelper;
+import tourplaner.object.Tour;
 
 import java.sql.Connection;
 import java.sql.DriverManager;
+import java.sql.ResultSet;
 import java.sql.Statement;
+import java.util.ArrayList;
 
 /**
  * Hilfsfunktionen für die verwendung der Postgres DB
  */
 public class PostgresHelper {
-
+    private Connection c;
+    private Statement stmt;
     /**
      * Verbindet mit der Datenbank
      * @return Das Connection Objekt
@@ -21,6 +25,8 @@ public class PostgresHelper {
         Connection c = null;
         try {
             Class.forName("org.postgresql.Driver");
+            System.out.println("jdbc:postgresql://" + ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "db", "url") + ":" + ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "db", "port") + "/" + ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "db", "dbname")+
+                    ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "db", "user")+ ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "db", "pw"));
             c = DriverManager
                     .getConnection("jdbc:postgresql://" + ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "db", "url") + ":" + ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "db", "port") + "/" + ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "db", "dbname"),
                             ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "db", "user"), ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "db", "pw"));

src/tourplaner/object/Log.java

@@ -6,15 +6,60 @@ import java.time.LocalDate;
 import java.util.Date;
 
 public class Log {
-    private String id, dauer;
+    private String id, bemerkung;
     private LocalDate datum;
-    private double strecke;
+    private double strecke, avgspeed, hightmeter, pause, dauer, gegangen;
 
-    public Log(String id, String dauer, LocalDate datum, double strecke) {
+    public Log(String id, double dauer, LocalDate datum, double strecke, String bemerkung, double hightmeter, double pause) {
         this.id = id;
         this.dauer = dauer;
         this.datum = datum;
         this.strecke = strecke;
+        this.bemerkung = bemerkung;
+        this.hightmeter = hightmeter;
+        this.pause = pause;
+        this.gegangen = this.dauer - this.pause;
+        this.avgspeed = this.strecke / (this.gegangen);
+    }
+
+    public String getBemerkung() {
+        return bemerkung;
+    }
+
+    public void setBemerkung(String bemerkung) {
+        this.bemerkung = bemerkung;
+    }
+
+    public double getAvgspeed() {
+        return avgspeed;
+    }
+
+    public void setAvgspeed(double avgspeed) {
+        this.avgspeed = avgspeed;
+    }
+
+    public double getHightmeter() {
+        return hightmeter;
+    }
+
+    public void setHightmeter(double hightmeter) {
+        this.hightmeter = hightmeter;
+    }
+
+    public double getPause() {
+        return pause;
+    }
+
+    public void setPause(double pause) {
+        this.pause = pause;
+    }
+
+    public double getGegangen() {
+        return gegangen;
+    }
+
+    public void setGegangen(double gegangen) {
+        this.gegangen = gegangen;
     }
 
     public String getId() {
@@ -25,11 +70,11 @@ public class Log {
         this.id = id;
     }
 
-    public String getDauer() {
+    public double getDauer() {
         return dauer;
     }
 
-    public void setDauer(String dauer) {
+    public void setDauer(double dauer) {
         this.dauer = dauer;
     }
 

src/tourplaner/object/Tour.java

@@ -21,6 +21,30 @@ public class Tour {
         this.log = new ArrayList<>();
     }
 
+    public Tour(String name, String dauer, String mapJson, double strecke, String start, String ziel, ArrayList<Log> logs) {
+        this.dauer = dauer;
+        this.mapJson = mapJson;
+        this.strecke = strecke;
+        this.name = name;
+        this.start = start;
+        this.ziel = ziel;
+        this.log = logs;
+    }
+
+    public void setTour(Tour tour){
+        this.dauer = tour.getDauer();
+        this.mapJson = tour.getMapJson();
+        this.strecke = tour.getStrecke();
+        this.name = tour.getName();
+        this.start = tour.getStart();
+        this.ziel = tour.getZiel();
+        this.log = tour.getLogs();
+    }
+
+    public void setLog(ArrayList<Log> log) {
+        this.log = log;
+    }
+
     /**
      * Holt einen einzigen Log Eintrag anhand der Id
      * @param id Id des Eintrags der zu besorgen ist

src/tourplaner/tourplaner.fxml

@@ -34,6 +34,7 @@
 
 <?import javafx.geometry.*?>
 <?import javafx.scene.control.*?>
+<?import javafx.scene.image.*?>
 <?import javafx.scene.layout.*?>
 <?import javafx.scene.paint.*?>
 <?import javafx.scene.text.*?>
@@ -45,16 +46,27 @@
         <Menu fx:id="menueFile" mnemonicParsing="false" text="Datei">
           <items>
             <MenuItem fx:id="beendenButton" mnemonicParsing="false" onAction="#quitApp" text="Beenden" />
+                  <MenuItem mnemonicParsing="false" onAction="#reportSum" text="Report alles" />
+                  <MenuItem mnemonicParsing="false" onAction="#tourReport" text="Tour Report erstellen" />
           </items>
         </Menu>
         <Menu mnemonicParsing="false" text="Bearbeiten">
                <items>
-                  <MenuItem mnemonicParsing="false" onAction="#nimpButton" text="Keine Funktion" />
+                  <MenuItem mnemonicParsing="false" onAction="#importBtn" text="Import" />
+                  <MenuItem mnemonicParsing="false" onAction="#exportBtn" text="Export" />
                </items>
         </Menu>
             <Menu mnemonicParsing="false" text="Optionen">
                <items>
                   <MenuItem mnemonicParsing="false" onAction="#nimpButton" text="Keine Funktion" />
+                  <CheckMenuItem mnemonicParsing="false" text="Map automatisch öffnen" />
+                  <CheckMenuItem mnemonicParsing="false" text="Report automatisch öffnen" />
+                  <Menu mnemonicParsing="false" text="Sprache">
+                    <items>
+                        <RadioMenuItem mnemonicParsing="false" text="Deutsch" />
+                        <RadioMenuItem mnemonicParsing="false" text="Englisch" />
+                    </items>
+                  </Menu>
                </items>
             </Menu>
         <Menu mnemonicParsing="false" text="Hilfe">
@@ -82,7 +94,7 @@
             <Insets bottom="3.0" left="3.0" right="3.0" top="3.0" />
          </padding>
       </HBox>
-    <SplitPane dividerPositions="0.21492204899777284" focusTraversable="true" prefHeight="522.0" prefWidth="900.0" VBox.vgrow="ALWAYS">
+    <SplitPane dividerPositions="0.060133630289532294" focusTraversable="true" prefHeight="522.0" prefWidth="300.0" VBox.vgrow="ALWAYS">
       <items>
             <AnchorPane prefWidth="239.0">
                <children>
@@ -111,15 +123,16 @@
                            <children>
                               <TabPane fx:id="viewTabPane" layoutX="1.0" layoutY="69.0" prefWidth="702.0" tabClosingPolicy="UNAVAILABLE" AnchorPane.bottomAnchor="-67.0" AnchorPane.leftAnchor="1.0" AnchorPane.rightAnchor="1.0" AnchorPane.topAnchor="0.0">
                                  <tabs>
-                                    <Tab fx:id="kartenTab" text="Karte">
+                                     <Tab fx:id="kartenTab" text="Karte">
-                                       <content>
+                                         <AnchorPane>
-                                          <AnchorPane />
+                                             <ImageView fx:id="mapImageView" pickOnBounds="true" preserveRatio="true" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0" />
-                                       </content></Tab>
+                                         </AnchorPane>
+                                     </Tab>
                                     <Tab fx:id="beschreibungTab" text="Beschreibung">
                                        <content>
                                           <AnchorPane>
                                              <children>
-                                                <TableView fx:id="beschreibungTableView" prefHeight="200.0" prefWidth="200.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
+                                                <TableView fx:id="beschreibungTableView" maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
                                                   <columns>
                                                     <TableColumn fx:id="nameCol" maxWidth="1.7976931348623157E308" minWidth="70.0" prefWidth="-1.0" text="Tourname" />
                                                     <TableColumn fx:id="dauerCol" maxWidth="1.7976931348623157E308" minWidth="40.0" prefWidth="-1.0" text="Dauer" />
@@ -142,7 +155,7 @@
                      <children>
                         <VBox prefWidth="100.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
                            <children>
-                              <AnchorPane prefWidth="676.0">
+                              <AnchorPane>
                                  <children>
                                     <HBox id="HBox" alignment="CENTER_LEFT" layoutY="2.0" prefWidth="702.0" spacing="5.0" AnchorPane.bottomAnchor="-2.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="2.0">
                                        <children>
@@ -169,13 +182,18 @@
                                     </HBox>
                                  </children>
                               </AnchorPane>
-                              <AnchorPane prefWidth="200.0">
+                              <AnchorPane>
                                  <children>
                                     <TableView fx:id="logTableView" onMouseClicked="#logItemSelected" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
                                       <columns>
-                                        <TableColumn fx:id="logDatumCol" prefWidth="238.0" text="Datum" />
+                                        <TableColumn fx:id="logDatumCol" prefWidth="49.0" text="Datum" />
-                                        <TableColumn fx:id="logDauerCol" prefWidth="223.0" text="Dauer" />
+                                        <TableColumn fx:id="logDauerCol" prefWidth="126.0" text="Dauer" />
                                           <TableColumn fx:id="logStreckeCol" prefWidth="240.0" text="Entfernung" />
+                                          <TableColumn fx:id="logAvgCol" prefWidth="75.0" text="AVG Geschwindigkeit" />
+                                          <TableColumn fx:id="logHightCol" prefWidth="75.0" text="Höhenmeter" />
+                                          <TableColumn fx:id="logPauseCol" prefWidth="75.0" text="Davon Pause" />
+                                          <TableColumn fx:id="logGegangenCol" prefWidth="75.0" text="Davon Unterwegs" />
+                                          <TableColumn fx:id="logBemerkungCol" prefWidth="75.0" text="Bemerkung" />
                                       </columns>
                                        <columnResizePolicy>
                                           <TableView fx:constant="CONSTRAINED_RESIZE_POLICY" />

src/tourplaner/ui/AlertHelper.java

@@ -11,6 +11,11 @@ import javafx.stage.Stage;
 import javafx.stage.WindowEvent;
 import tourplaner.business.ConfigHelper;
 
+import javax.swing.*;
+import javax.swing.border.TitledBorder;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+import java.awt.*;
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.time.LocalDate;
@@ -109,23 +114,40 @@ public class AlertHelper {
     }
 
     /**
-     * Texteingabe
+     * Texteingabe die nicht leer sein darf
      * @param title Title des Dialogs
      * @param header Header des Dialogs
      * @param msg Nachricht des Dialogs
      * @return Null bei keiner eingabe
      */
-    public static String inputText(String title, String header, String msg, String content) {
+    public static String inputText(String title, String header, String msg, String content){
-        String returnStr = "";
+        return inputTextNotNull(title, header, msg, content, true);
-        while (returnStr.isEmpty()) {
+    }
+
+    /**
+     * Texteingabe
+     * @param title Title des Dialogs
+     * @param header Header des Dialogs
+     * @param msg Nachricht des Dialogs
+     * @param notNull true wenn der input nicht leer sein darf
+     * @return Null bei keiner eingabe
+     */
+    public static String inputTextNotNull(String title, String header, String msg, String content, boolean notNull) {
+        String returnStr = null;
+        while (returnStr == null) {
             Optional<String> result = inputHelper(title, header, msg, content);
+
             AtomicReference<String> returnText = new AtomicReference<>("");
-            result.ifPresent(returnText::set);
+            if(result.isPresent()) {
-            returnStr = returnText.get();
+                result.ifPresent(returnText::set);
-            if (returnStr.isEmpty()) {
+                returnStr = returnText.get();
-                AlertHelper.warn(ConfigHelper.getLangIniString("tournametitle"),
+                if (returnStr.isEmpty() && notNull) {
-                        ConfigHelper.getLangIniString("achtung"),
+                    AlertHelper.warn(ConfigHelper.getLangIniString("tournametitle"),
-                        ConfigHelper.getLangIniString("keintextimfeld"));
+                            ConfigHelper.getLangIniString("achtung"),
+                            ConfigHelper.getLangIniString("keintextimfeld"));
+                }
+            }else{
+                return "";
             }
         }
         return returnStr;
@@ -212,4 +234,24 @@ public class AlertHelper {
         stage.showAndWait();
         return selectedDate.get();
     }
+
+
+    /**
+     * File Auswahl
+     * @param btn Text des Speichern/Öffnen Btn
+     * @return String des Files, bei error null
+     */
+    public static String fileChooser(String btn){
+        // JFileChooser-Objekt erstellen
+        JFileChooser chooser = new JFileChooser();
+        // Dialog zum Oeffnen von Dateien anzeigen
+        int rueckgabeWert = chooser.showDialog(null, btn);
+
+        /* Abfrage, ob auf "Öffnen" geklickt wurde */
+        if(rueckgabeWert == JFileChooser.APPROVE_OPTION)
+        {
+            return chooser.getSelectedFile().getAbsolutePath();
+        }
+        return null;
+    }
 }

src/tourplaner/ui/ProgressBar.java

@@ -0,0 +1,45 @@
+package tourplaner.ui;
+
+import javax.swing.*;
+import javax.swing.border.TitledBorder;
+import java.awt.*;
+
+public class ProgressBar {
+    private int status;
+    private JFrame frame;
+    private JProgressBar progressBar;
+
+    public ProgressBar(String title){
+        this.frame = new JFrame(title);
+        this.frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
+        Container content = this.frame.getContentPane();
+        this.progressBar = new JProgressBar();
+        this.progressBar.setValue(0);
+        this.progressBar.setStringPainted(true);
+        TitledBorder border = BorderFactory.createTitledBorder("Laden....");
+        this.progressBar.setBorder(border);
+        content.add(this.progressBar, BorderLayout.NORTH);
+        this.frame.setSize(300, 100);
+        this.frame.setVisible(true);
+    }
+
+    public void addProgress(int add){
+        this.status += add;
+        System.out.println("PROGRESS: " + this.status);
+        this.progressBar.setValue(this.status);
+        if(this.status == 100){
+            frame.setVisible(false);
+        }
+    }
+
+    public void closeProgress(){
+        this.frame.setVisible(false);
+    }
+
+    public int getProgressSize(int todo, int maxLevel){
+        int steps = (progressBar.getValue() - maxLevel) / todo;
+        if(steps < 0) steps = steps*-1;
+        System.out.println("STEPS: " + steps);
+        return steps;
+    }
+}

src/tourplaner/ui/TourplanerController.java

@@ -8,13 +8,16 @@ import javafx.scene.control.*;
 import javafx.scene.control.Label;
 import javafx.scene.control.TextField;
 import javafx.scene.control.cell.PropertyValueFactory;
+import javafx.scene.image.ImageView;
 import javafx.scene.input.MouseEvent;
 import tourplaner.business.ConfigHelper;
 import tourplaner.business.LogHelper;
+import tourplaner.business.TourPlaner;
 import tourplaner.object.Log;
 import tourplaner.object.Tour;
 import tourplaner.viewmodels.ViewModel;
 
+import javax.swing.*;
 import java.awt.*;
 import java.io.IOException;
 import java.net.URI;
@@ -36,19 +39,31 @@ public class TourplanerController implements Initializable {
     public TableView<Tour> beschreibungTableView;
     public TableColumn<Tour, String> startCol, zielCol, dauerCol, streckeCol, nameCol;
     public TextField titleTextView, sucheInput;
+    public ImageView mapImageView;
     //Log -> rechts unten
     public TableView<Log> logTableView;
-    public TableColumn<Log, String> logDauerCol, logStreckeCol, logDatumCol;
+    public TableColumn<Log, String> logDauerCol, logStreckeCol, logDatumCol, logAvgCol, logHightCol, logPauseCol, logGegangenCol, logBemerkungCol;
+
+    @FXML
+    private void tourReport(){
+        this.viewModel.tourReport();
+    }
 
 
     @FXML
     private void editTourBtn(){
-        this.viewModel.editTour();
+        try {
+            this.viewModel.editTour();
+        } catch (IOException e) {
+            LogHelper.error(e);
+        }
+        syncTour(this.viewModel.getSelectedTour().getName());
     }
 
     @FXML
     private void editLogBtn(){
         this.viewModel.editLog();
+        syncLogs();
     }
     /**
      * Öffnet github im standart browser
@@ -77,6 +92,21 @@ public class TourplanerController implements Initializable {
         this.viewModel.doxygenDocBrowser();
     }
 
+    private void syncTour(String selectedItem){
+        beschreibungTableView.getItems().clear(); //Leert die Table View komplett
+        beschreibungTableView.getItems().add(this.viewModel.getTour(selectedItem));
+        mapImageView.setImage(this.viewModel.getImage(selectedItem));
+    }
+
+    private void syncTourNamen(){
+        TourListView.getItems().clear();
+        TourListView.setItems(this.viewModel.getTourNamen());
+    }
+
+    private void syncLogs(){
+        logTableView.getItems().clear();
+        logTableView.setItems(this.viewModel.getLogData());
+    }
 
 
     /**
@@ -85,11 +115,13 @@ public class TourplanerController implements Initializable {
      */
     @FXML
     private void tourListSelectedItem(MouseEvent mouseEvent){
+        ProgressBar progressBar = new ProgressBar("Tour auswählen...");
         String selectedItem = TourListView.getSelectionModel().getSelectedItem();
         this.viewModel.selectTour(selectedItem);
         titleTextView.setText(selectedItem);
-        beschreibungTableView.getItems().removeIf(s -> true); //Leert die Table View komplett
+        progressBar.addProgress(10);
-        beschreibungTableView.getItems().add(this.viewModel.getTour(selectedItem));
+        syncTour(selectedItem);
+        progressBar.addProgress(10);
         startCol.setCellValueFactory(new PropertyValueFactory<Tour, String>("start"));
         zielCol.setCellValueFactory(new PropertyValueFactory<Tour, String>("ziel"));
         dauerCol.setCellValueFactory(new PropertyValueFactory<Tour, String>("dauer"));
@@ -98,10 +130,28 @@ public class TourplanerController implements Initializable {
 
         //Log anzeigen
         logTableView.setPlaceholder(new Label( ConfigHelper.getLangIniString("keinelogsvorhanden")));
+        logTableView.getItems().clear();
+        progressBar.addProgress(10);
         logTableView.setItems(this.viewModel.getLogData());
+        progressBar.addProgress(10);
         logDauerCol.setCellValueFactory(new PropertyValueFactory<Log, String>("dauer"));
         logStreckeCol.setCellValueFactory(new PropertyValueFactory<Log, String>("strecke"));
         logDatumCol.setCellValueFactory(new PropertyValueFactory<Log, String>("datum"));
+        logAvgCol.setCellValueFactory(new PropertyValueFactory<Log, String>("avgspeed"));
+        logHightCol.setCellValueFactory(new PropertyValueFactory<Log, String>("hightmeter"));
+        logPauseCol.setCellValueFactory(new PropertyValueFactory<Log, String>("pause"));
+        logGegangenCol.setCellValueFactory(new PropertyValueFactory<Log, String>("gegangen"));
+        logBemerkungCol.setCellValueFactory(new PropertyValueFactory<Log, String>("bemerkung"));
+        progressBar.addProgress(10);
+        mapImageView.setImage(this.viewModel.getImage(this.viewModel.getSelectedTour().getName()));
+        if(this.viewModel.isSucheAktiv()){
+            this.viewModel.setSucheAktiv(false);
+            progressBar.addProgress(10);
+            syncTourNamen();
+            progressBar.addProgress(40);
+            this.sucheInput.setText("");
+        }
+        progressBar.addProgress(50);
     }
 
     /**
@@ -120,6 +170,7 @@ public class TourplanerController implements Initializable {
     @FXML
     private void addTour(){
         this.viewModel.addTour();
+        this.mapImageView.setImage(this.viewModel.getImage(this.viewModel.getSelectedTour().getName()));
     }
 
     /**
@@ -128,10 +179,11 @@ public class TourplanerController implements Initializable {
      */
     @FXML
     private void delTour(){
-        this.beschreibungTableView.getItems().removeIf(s -> true); //löscht alles aus der tabelle
+        this.beschreibungTableView.getItems().clear(); //löscht alles aus der tabelle
         this.titleTextView.setText(ConfigHelper.getLangIniString("keinetourselected"));
         this.viewModel.delTour();
         logTableView.setPlaceholder(new Label( ConfigHelper.getLangIniString("keinetourselected")));
+        mapImageView.setImage(null);
     }
 
     /**
@@ -140,7 +192,10 @@ public class TourplanerController implements Initializable {
      */
     @FXML
     private void suche(){
+        ProgressBar progressBar = new ProgressBar("Suche");
         this.viewModel.suche(this.sucheInput.getText());
+        progressBar.addProgress(100);
+        progressBar.closeProgress();
     }
 
     /**
@@ -150,12 +205,13 @@ public class TourplanerController implements Initializable {
     @FXML
     private void addLog(){
         this.viewModel.addLog();
+        syncLogs();
     }
 
     @FXML
     private void delLog(){
         this.viewModel.delLog();
-
+        syncLogs();
     }
 
     /**
@@ -177,13 +233,34 @@ public class TourplanerController implements Initializable {
         //Tour list -> links
         TourListView.getSelectionModel().setSelectionMode(SelectionMode.SINGLE);
         TourListView.setOrientation(Orientation.VERTICAL);
-        TourListView.setItems(this.viewModel.getTourNamen());
+        syncTourNamen();
+        deselectAll();
+
+    }
+
+    private void deselectAll(){
         //Tabs zu Tour -> rechts oben
         beschreibungTableView.setPlaceholder(new Label( ConfigHelper.getLangIniString("keinetourselected")));
         titleTextView.setText( ConfigHelper.getLangIniString("keinetourselected"));
         //Log -> rechts unten
         logTableView.setPlaceholder(new Label( ConfigHelper.getLangIniString("keinetourselected")));
+    }
 
+    @FXML
+    private void exportBtn(){
+        this.viewModel.exportData();
+    }
+
+    @FXML
+    private void importBtn(){
+        deselectAll();
+        this.viewModel.importData();
+        syncTourNamen();
+    }
+
+    @FXML
+    private void reportSum(){
+        this.viewModel.sumReport();
     }
 
     /**

src/tourplaner/viewmodels/ViewModel.java

@@ -2,37 +2,46 @@ package tourplaner.viewmodels;
 
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
+import javafx.scene.image.Image;
+import tourplaner.business.*;
 import tourplaner.ui.AlertHelper;
-import tourplaner.business.ConfigHelper;
-import tourplaner.business.LogHelper;
 import tourplaner.object.Log;
 import tourplaner.object.Tour;
 
+import javax.swing.*;
 import java.awt.*;
+import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.time.LocalDate;
+import java.util.ArrayList;
 import java.util.UUID;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
 public class ViewModel {
     //Tour
-    private final ObservableList<Tour> tourData = FXCollections.observableArrayList(new Tour("Test 1", "120", "json dings", 22.3, "Wien", "Graz"),new Tour("Test 2", "210", "json dings", 42.3, "Da", "Dort"));
+    private final ObservableList<Tour> tourData = FXCollections.observableArrayList();
-    private final ObservableList<String> tourNamen = FXCollections.observableArrayList("Test 1", "Test 2");
+    private ObservableList<String> tourNamen = FXCollections.observableArrayList();
     private Tour selectedTour;
-    private String neueTourName, neueTourStart, neueTourZiel;
+    private String neueTourName, neueTourStart, neueTourZiel, neueBemerkung;
     //Log
     private final ObservableList<Log> logData = FXCollections.observableArrayList();
     private Log selectedLog;
+// Suche
+    private boolean sucheAktiv;
 
 
+    public Image getImage(String tourname){
+        return new Image( ConfigHelper.getIniString(ConfigHelper.getStandartConfig(), "map", "file_pre") + TourPlaner.getImagePath(tourname));
+    }
 
     /**
      * Bearbeitet eine bereits bestehende Tour
+     * prüft ob eine tour ausgewählt ist
      */
-    public void editTour(){
+    public void editTour() throws IOException {
         if (this.selectedTour == null){
             AlertHelper.warn(ConfigHelper.getLangIniString("achtung"),
                     ConfigHelper.getLangIniString("keinetourselected"),
@@ -47,35 +56,52 @@ public class ViewModel {
                 }
             });
             if(aktIndex.intValue() != -1){
-                Tour tourToEdit = this.tourData.get(aktIndex.intValue());
-                this.tourData.removeIf(tour -> tour.getName().equals(this.selectedTour.getName()));
-                this.tourNamen.removeIf(tour -> tour.equals(this.selectedTour.getName()));
-                System.out.println(tourToEdit.getLogs());
-                tourNameInput(this.selectedTour.getName());
-                tourToEdit.setName(this.neueTourName);
-                tourStartInput(this.selectedTour.getStart());
-                tourToEdit.setStart(this.neueTourStart);
-                tourZielInput(this.selectedTour.getZiel());
-                tourToEdit.setZiel(this.neueTourZiel);
-                System.out.println(tourToEdit.getName());
 
-                this.tourData.add(new Tour(this.neueTourName, "TBD", "TBD", 0, this.neueTourStart, this.neueTourZiel));
+                if(tourNameInputDuplicatCheck(this.selectedTour.getName(), false)) {
-                this.tourNamen.add(this.neueTourName);
+                    if (tourStartInput(this.selectedTour.getStart())) {
-//                this.tourData.add(tourToEdit);
+                        if (tourZielInput(this.selectedTour.getZiel())) {
+
+                            this.tourData.removeIf(tour -> tour.getName().equals(this.selectedTour.getName()));
+                            this.tourNamen.removeIf(tour -> tour.equals(this.selectedTour.getName()));
+                            Tour newTour = new Tour(this.neueTourName, "TBD", "TBD", 0, this.neueTourStart, this.neueTourZiel);
+                            this.tourData.add(newTour);
+                            this.tourNamen.add(this.neueTourName);
+                            LogHelper.info("Edit Tour: " + this.neueTourName + " upload zu Postgres war: " + TourPlaner.editTour(this.selectedTour.getName(), newTour), "ViewModel - EditTour");
+                            selectTour(this.neueTourName);
+                        }
+                    }
+                }
+                this.neueTourName = null;
+                this.neueTourStart = null;
+                this.neueTourZiel = null;
             }
         }
     }
 
+    /**
+     * Input mit duplications check des Namens und ohne content im input feld
+     */
+    private void tourNameInput(){
+        tourNameInputDuplicatCheck("", true);
+    }
+
     /**
      * Input des Tour Namen wird so lange durchgeführt, bis er korrekt ist. Das heißt:
      * er darf nicht schon vorhanden sein und er darf nicht Null sein
+     * @param checkDuplicate Prüft ob name bereits vorhanden ist
+     * @param content inhalt des Input fields
+     * @return false beim schließen des input dialogs
      */
-    private void tourNameInput(String content){
+    private boolean tourNameInputDuplicatCheck(String content, boolean checkDuplicate){
         while(this.neueTourName == null) {
             this.neueTourName = AlertHelper.inputText(ConfigHelper.getLangIniString("tournametitle"),
                     ConfigHelper.getLangIniString("tournameheader"),
                     ConfigHelper.getLangIniString("tournamemsg"), content);
-            if (getTour(this.neueTourName) != null) {
+            System.out.println(this.neueTourName);
+            if(this.neueTourName.isEmpty()){
+                return false;
+            }
+            if (getTour(this.neueTourName) != null && checkDuplicate) {
                 AlertHelper.warn(ConfigHelper.getLangIniString("achtung"),
                         ConfigHelper.getLangIniString("namevergebenheader"),
                         ConfigHelper.getLangIniString("namevergebenmsg1")
@@ -84,30 +110,43 @@ public class ViewModel {
                 this.neueTourName = null;
             }
         }
+        return true;
     }
 
     /**
      * Input der Startpunkt der Tour
      * Wird erst beendet wenn die eingabe erfolgreich war
+     * @param content inhalt des Input fields
+     * @return false beim schließen des input dialogs
      */
-    private void tourStartInput(String content){
+    private boolean tourStartInput(String content){
         while(this.neueTourStart == null){
             this.neueTourStart = AlertHelper.inputText(ConfigHelper.getLangIniString("startpunkttitle"),
                     ConfigHelper.getLangIniString("startpunktheader"),
                     ConfigHelper.getLangIniString("startpunktmsg"), content);
+            if(this.neueTourStart.isEmpty()){
+                return false;
+            }
         }
+        return true;
     }
 
     /**
      * Input des Zielpunktes der Tour
      * Wird erst beendet wenn die eingabe erfolgreich war
+     * @param content inhalt des Input fields
+     * @return false beim schließen des input dialogs
      */
-    private void tourZielInput(String content){
+    private boolean tourZielInput(String content){
         while(this.neueTourZiel == null){
             this.neueTourZiel = AlertHelper.inputText(ConfigHelper.getLangIniString("zielpunkttitle"),
                     ConfigHelper.getLangIniString("zielpunktheader"),
                     ConfigHelper.getLangIniString("zielpunktmsg"), content);
+            if(this.neueTourZiel.isEmpty()){
+                return false;
+            }
         }
+        return true;
     }
 
 
@@ -115,12 +154,19 @@ public class ViewModel {
      * Fügt eine neue Tour hinzu
      */
     public void addTour(){
-        tourNameInput("");
+        tourNameInput();
         tourStartInput("");
         tourZielInput("");
         if (getTour(this.neueTourName) == null) {
-            tourData.add(new Tour(this.neueTourName, "TBD", "TBD", 0, this.neueTourStart, this.neueTourZiel));
+            Tour newTour = new Tour(this.neueTourName, "1", "1", 0, this.neueTourStart, this.neueTourZiel);
+            tourData.add(newTour);
             tourNamen.add(this.neueTourName);
+            this.selectedTour = newTour;
+            try {
+                TourPlaner.addTour(newTour);
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
         }
         this.neueTourStart = null;
         this.neueTourZiel = null;
@@ -156,22 +202,36 @@ public class ViewModel {
         });
         double dauer = dauerInput(this.selectedLog.getDauer());
         double strecke = -1;
+        double pause = -1.0;
+        double hightmeter = -1.0;
+        boolean bemerkung = false;
         LocalDate datum = null;
         if (dauer >= 0) {
             strecke = streckeInput(this.selectedLog.getStrecke() + "");
             if (strecke >= 0) {
-                datum = dateInput(this.selectedLog.getDatum());
+                pause = pauseInput("");
-                if(datum != null){
+                if(pause >= 0.0) {
-                    Log newLog = new Log(this.selectedLog.getId(), dauer + "", datum,strecke);
+                    hightmeter = hightmeterInput("");
-                    this.logData.removeIf(ld -> ld.getId().equals(this.selectedLog.getId()));
+                    if (hightmeter >= 0.0) {
-                    this.logData.add(newLog);
+                        bemerkung = bemerkungInput("");
-                    tourAkt.get().delLog(this.selectedLog.getId());
+                        if (bemerkung) {
-                    tourAkt.get().addLog(newLog);
+                            datum = dateInput(this.selectedLog.getDatum());
-                    this.tourData.removeIf(td -> td.getName().equals(this.selectedTour.getName()));
+                            if (datum != null) {
-                    this.tourData.add(tourAkt.get());
+                                Log newLog = new Log(this.selectedLog.getId(), dauer, datum, strecke, this.neueBemerkung, hightmeter, pause);
+                                this.logData.removeIf(ld -> ld.getId().equals(this.selectedLog.getId()));
+                                this.logData.add(newLog);
+//                                tourAkt.get().delLog(this.selectedLog.getId());
+//                                tourAkt.get().addLog(newLog);
+                                this.tourData.removeIf(td -> td.getName().equals(this.selectedTour.getName()));
+                                this.tourData.add(tourAkt.get());
+                                TourPlaner.editLog(this.selectedTour.getName(), newLog);
+                            }
+                        }
+                    }
                 }
             }
         }
+        this.neueBemerkung = null;
     }
 
     /**
@@ -187,13 +247,18 @@ public class ViewModel {
 
     /**
      * Eingabe der Dauer bis sie korrekt ist
+     * @param content Wenn der Content -1.0 ist, wird er nicht in das input feld eingeschleust, sonst schon
      * @return Die eingegebene Dauer
      */
-    private double dauerInput(String content){
+    private double dauerInput(double content){
+        String realcontent = "";
+        if (content != -1){
+            realcontent = content + "";
+        }
         return AlertHelper.inputNumber(ConfigHelper.getLangIniString("dauer"),
                 ConfigHelper.getLangIniString("dauermsg"),
                 ConfigHelper.getLangIniString("dauer") +
-                        ConfigHelper.getLangIniString("doppelpunkt"), content);
+                        ConfigHelper.getLangIniString("doppelpunkt"), realcontent);
     }
 
     /**
@@ -207,6 +272,38 @@ public class ViewModel {
         return neuesDatum;
     }
 
+    /**
+     * Bemerkung input, darf auch leer bleiben
+     * @param content Startwert im Input feld
+     * @return True bei erfolg, wenn es abgebrochen wird ist es false
+     */
+    private boolean bemerkungInput(String content){
+        this.neueBemerkung = AlertHelper.inputTextNotNull(ConfigHelper.getLangIniString("bemerkung"),
+                ConfigHelper.getLangIniString("bemerkungheader"),
+                ConfigHelper.getLangIniString("bemerkung")+
+                        ConfigHelper.getLangIniString("doppelpunkt"), content, false);
+        return !(this.neueBemerkung == null);
+    }
+
+    private double hightmeterInput(String content) {
+        return AlertHelper.inputNumber(ConfigHelper.getLangIniString("hightmeter"),
+                ConfigHelper.getLangIniString("hightmetermsg"),
+                ConfigHelper.getLangIniString("hightmeter") +
+                        ConfigHelper.getLangIniString("doppelpunkt"), content);
+    }
+
+    /**
+     * Pause eingabe bis diese Korrekt ist
+     * @param content Default value für das Input Feld
+     * @return -1 bei error
+     */
+    private double pauseInput(String content){
+        return AlertHelper.inputNumber(ConfigHelper.getLangIniString("pause"),
+                ConfigHelper.getLangIniString("pausemsg"),
+                ConfigHelper.getLangIniString("pause") +
+                        ConfigHelper.getLangIniString("doppelpunkt"), content);
+    }
+
     /**
      * Fügt einen Log eintrag zu einer Tour hinzu.
      * Ist keine Tour ausgewählt, dann kommt eine Warnung an den User!
@@ -222,22 +319,34 @@ public class ViewModel {
                             newId.set(UUID.randomUUID().toString());
                         }
                     });
-                    double dauer = dauerInput("");
+                    double dauer = dauerInput(-1.0);
-                    double strecke;
+                    double strecke, pause, hightmeter;
+                    boolean bemerkung = false;
                     LocalDate date = null;
                     if(dauer >= 0) {
                         strecke = streckeInput("");
                         if (strecke >= 0.0) {
-                            date = dateInput(LocalDate.now());
+                            pause = pauseInput("");
-                                if (date != null){
+                            if(pause >= 0.0) {
-                                    Log newLog = new Log(newId.get(), dauer + "", date, strecke);
+                                hightmeter = hightmeterInput("");
-                                    this.logData.add(newLog);
+                                if (hightmeter >= 0.0) {
-                                    s.addLog(newLog);
+                                     bemerkung = bemerkungInput("");
+                                     if (bemerkung){
+                                        date = dateInput(LocalDate.now());
+                                        if (date != null) {
+                                            Log newLog = new Log(newId.get(), dauer, date, strecke, this.neueBemerkung, hightmeter, pause);
+                                            this.logData.add(newLog);
+                                            TourPlaner.addLog(this.selectedTour.getName(), newLog);
+                                            s.addLog(newLog);
+                                        }
+                                    }
                                 }
+                            }
                         }
                     }
                 }
             });
+            this.neueBemerkung = null;
         }
     }
 
@@ -249,25 +358,8 @@ public class ViewModel {
      */
     public void delLog(){
         if(this.selectedLog != null) {
-            this.logData.removeIf(s -> s.getId().equals(this.selectedLog.getId()));
+                TourPlaner.delLog(this.selectedTour.getName(), this.selectedLog.getId());
-            AtomicReference<Tour> tourToEdit = new AtomicReference<>();
-            this.tourData.forEach(s -> {
-                if (s.getLogs() != null) {
-                    s.getLogs().forEach(ss -> {
-                        if (ss.getId().equals(this.selectedLog.getId())) {
-                            tourToEdit.set(s);
-                        }
-                    });
-                }
-            });
-
-            if (tourToEdit.get() != null){
-                Tour toEdit = tourToEdit.get();
-                toEdit.delLog(this.selectedLog.getId());
-                this.tourData.removeIf(s -> s.getName().equals(toEdit.getName()));
-                this.tourData.add(toEdit);
                 this.selectedLog = null;
-            }
         }else{
             AlertHelper.warn(ConfigHelper.getLangIniString("achtung"),
                     ConfigHelper.getLangIniString("keinetourselected"),
@@ -307,6 +399,8 @@ public class ViewModel {
     }
 
     public ObservableList<Log> getLogData() {
+        logData.removeAll();
+        logData.addAll(TourPlaner.getLogs(this.selectedTour.getName()));
         return logData;
     }
 
@@ -361,6 +455,12 @@ public class ViewModel {
     }
 
     public ObservableList<String> getTourNamen() {
+        ArrayList<String> namen = new ArrayList<>();
+        getTourData().forEach(s -> {
+            namen.add(s.getName());
+        });
+        tourNamen.clear();
+        tourNamen.addAll(namen);
         return tourNamen;
     }
 
@@ -381,6 +481,8 @@ public class ViewModel {
     }
 
     public ObservableList<Tour> getTourData() {
+        tourData.clear();
+        tourData.addAll(TourPlaner.getAllTours());
         return tourData;
     }
 
@@ -394,6 +496,7 @@ public class ViewModel {
             tourNamen.removeIf(s -> s.equals(tourname));
             logData.removeIf(s -> true);
             setSelectedTour(null);
+            TourPlaner.delTour(tourname);
         }catch (NullPointerException e){
             LogHelper.error(ConfigHelper.getLangIniString("keinetourselected"),
                     ConfigHelper.getLangIniString("deltournoselect"));
@@ -413,7 +516,20 @@ public class ViewModel {
                     ConfigHelper.getLangIniString("suchfeldleer"),
                     ConfigHelper.getLangIniString("suchtextzuerst"));
         }
-            // TODO: 19.03.2021 Suchlogik
+         ArrayList<Tour> result = TourPlaner.sucheTour(sucheInput);
+        tourNamen.clear();
+        for (Tour tour:result) {
+            tourNamen.add(tour.getName());
+        }
+        this.sucheAktiv = true;
+    }
+
+    public boolean isSucheAktiv() {
+        return sucheAktiv;
+    }
+
+    public void setSucheAktiv(boolean sucheAktiv) {
+        this.sucheAktiv = sucheAktiv;
     }
 
     /**
@@ -467,4 +583,56 @@ public class ViewModel {
                 ConfigHelper.getLangIniString("fktnichtimplementiert"),
                 ConfigHelper.getLangIniString("vergessenodernochnichtsoweit"));
     }
+
+    /**
+     * Startet den Tour Report
+     */
+    public void tourReport() {
+        if (this.selectedTour == null){
+            AlertHelper.warn(ConfigHelper.getLangIniString("achtung"),
+                    ConfigHelper.getLangIniString("keinetourselected"),
+                    ConfigHelper.getLangIniString("logtournotselectedmsg"));
+        }else {
+           TourPlaner.doReport(this.selectedTour.getName());
+        }
+    }
+
+    /**
+     * Exportiert alle daten in ein File das hier gewählt wird
+     */
+    public void exportData(){
+        String file = AlertHelper.fileChooser("Exportiere");
+        System.out.println("EXPORT: " + file);
+        if(file != null){
+            try {
+                new Exporter(file).doExport();
+            } catch (IOException e) {
+                AlertHelper.error("Error", "Export Error", "Fehler beim Exportieren");
+                LogHelper.error(e);
+            }
+        }
+    }
+
+    /**
+     * Importiert alle daten von einem File das hier gewählt wird
+     */
+    public void importData() {
+        String file = AlertHelper.fileChooser("Importiere");
+        if (file != null){
+            try {
+                this.tourNamen = FXCollections.observableArrayList();
+                new Exporter(file).doImport();
+            } catch (IOException e) {
+                AlertHelper.error("Error", "Import Error", "Fehler beim Importieren");
+                LogHelper.error(e);
+            }
+        }
+    }
+
+    /**
+     * Erstellt einen Summary Report
+     */
+    public void sumReport(){
+        Reporter.sumReport();
+    }
 }