Merge remote-tracking branch 'origin/logging_and_docs' into testing

# Conflicts:
#	app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Factory.java
#	app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FactoryDecorator.java
#	app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/LogConfiguration.java
#	app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindow.java
#	app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindowController.java
#	app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/AlertNewSchedule.java
#	app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameController.java

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/App.java

@@ -11,9 +11,11 @@ import java.io.IOException;
 public class App {
     public static void main(String[] args) {
         try {
-            new LogConfiguration(System.getProperty("user.dir") + System.getProperty("file.separator") + "tournierverwaltung_angrynerds",
+            new LogConfiguration(System.getProperty("user.dir") + System.getProperty("file.separator") +
-                    "ch" + System.getProperty("file.separator") + "zhaw" + System.getProperty("file.separator") + "projekt2" + System.getProperty("file.separator") +
+                    "tournierverwaltung_angrynerds", "ch" + System.getProperty("file.separator") + "zhaw" +
-                    "turnierverwaltung" + System.getProperty("file.separator") + "logging" + System.getProperty("file.separator") + "log.properties");
+                    System.getProperty("file.separator") + "projekt2" + System.getProperty("file.separator") +
+                    "turnierverwaltung" + System.getProperty("file.separator") + "logging" +
+                    System.getProperty("file.separator") + "log.properties");
         } catch (IOException e) {
             throw new RuntimeException(e);
         }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Factory.java

@@ -9,22 +9,24 @@ import javafx.scene.layout.*;
 import javafx.scene.paint.Color;
 import javafx.scene.text.Font;
 import java.io.IOException;
+import java.util.logging.Logger;
 
+/**
+ *
+ */
 public class Factory {
     private TournamentDecorator tournamentDecorator;
     private FileIO fileIO;
     private static LanguageConfigurator languageConfigurator;
 
+    private static final Logger logger = Logger.getLogger(Factory.class.getCanonicalName());
+
     public Factory(FileIO fileIO, TournamentDecorator tournamentDecorator, LanguageConfigurator languageConfigurator) {
         this.fileIO = fileIO;
         this.tournamentDecorator = tournamentDecorator;
         this.languageConfigurator = languageConfigurator;
     }
 
-    public TournamentDecorator getTournamentDecorator() {
-        return tournamentDecorator;
-    }
-
     public void setTournament(Tournament tournament) {
         this.tournamentDecorator.setTournament(tournament);
     }
@@ -37,8 +39,8 @@ public class Factory {
             controller.setup(languageConfigurator);
             return pane;
         } catch (IOException e) {
+            logger.warning("Fatal error program can not continue after this: " + e );
             e.printStackTrace();
-            //TODO handle and logging
         }
         return null;
     }
@@ -88,8 +90,8 @@ public class Factory {
             controller.setup(tournamentDecorator, fileIO, factoryDecorator, box, gameDecorator, languageConfigurator);
             return controller;
         } catch (IOException e) {
+            logger.warning("Fatal error program can not continue after this: " + e );
             e.printStackTrace();
-            //TODO LOGGER
         }
         return null;
     }
@@ -119,6 +121,11 @@ public class Factory {
         }
     }
 
+    /**
+     *
+     * @param pane
+     * @param error
+     */
     public void resetFooter(BorderPane pane,boolean error) {
         VBox bottom = (VBox) pane.getBottom();
         VBox vBox;
@@ -135,6 +142,9 @@ public class Factory {
         return languageConfigurator;
     }
 
+    /**
+     * Enum for keeping the different fxml form views
+     */
     public enum View {
         tournamentList("tournamentList/tournamentList.fxml"),
         participantFormular("participantAddFormular/participantFormular.fxml"),

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FactoryDecorator.java

@@ -12,64 +12,129 @@ import javafx.scene.shape.Line;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.logging.Logger;
 
+/**
+ * Factory Decorator Class giving additional functionality to the factory and holding the listeners in itself.
+ */
 public class FactoryDecorator implements IsObservable {
     private Factory factory;
     private FileIO fileIO;
     private Pane pane;
-    private List<IsObserver> listener = new ArrayList<>();
+    private final List<IsObserver> listener = new ArrayList<>();
 
+    private static final Logger logger = Logger.getLogger(FactoryDecorator.class.getCanonicalName());
+
+    /**
+     * Setup of Factory Decorator with needed classes
+     *
+     * @param fileIO  for Reading and Saving Files
+     * @param factory factory which this class adds additional functionality to
+     * @param pane    standard pane
+     */
     public FactoryDecorator(FileIO fileIO, Factory factory, Pane pane) {
+        logger.fine("Setting up the Factory decorator");
         setFactory(factory);
         setFileIO(fileIO);
         setPane(pane);
     }
 
+    /**
+     * Setting the File IO Class for its functionality
+     *
+     * @param fileIO for reading and saving to and from a file
+     */
     public void setFileIO(FileIO fileIO) {
+        logger.finer("Setting the FileIO to the FactoryDecorator");
         this.fileIO = fileIO;
     }
 
+    /**
+     * Setting the main class
+     *
+     * @param factory needed for the main functionality
+     */
     public void setFactory(Factory factory) {
+        logger.finer("Setting the factory to the FactoryDecorator");
         this.factory = factory;
     }
 
+    /**
+     * Setting of the given pane to the factory decorator
+     *
+     * @param pane that will be set
+     */
     public void setPane(Pane pane) {
+        logger.finer("Setting the pane to the FactoryDecorator");
         this.pane = pane;
     }
 
+    /**
+     * Method adds a new Listener to the listener list
+     *
+     * @param observer that is being added to the Listener List
+     */
     @Override
     public void addListener(IsObserver observer) {
+        logger.fine("Adding Listener: " + observer);
         listener.add(observer);
     }
 
+    /**
+     * Removes a Listener from the Listener List
+     *
+     * @param observer the Listener to be removed
+     */
     @Override
     public void removeListener(IsObserver observer) {
+        logger.fine("Removing Listener: " + observer);
         listener.remove(observer);
     }
 
+    /**
+     * Opens a tournament File in connection with the File IO Class, shows error Message if error occurs while opening
+     * it.
+     *
+     * @param tournamentFile the File to be opened
+     */
     public void openTournament(FileIO.TournamentFile tournamentFile) {
+        logger.finer("Trying to open tournament file:" + tournamentFile);
         try {
             factory.setTournament(fileIO.loadTournament(tournamentFile));
             openScheduleView();
             clearMessage(false);
+            logger.fine("Opened tournament file successfully");
         } catch (IOException | ClassNotFoundException e) {
             e.printStackTrace();
             String msg = factory.getLanguageConfigurator().getSelectedLanguage("IOException");
+            logger.warning("Failed to open tournament file Error: " + e);
             printMessageToFooter(msg, true);
-        }  //TODO handle and logging
+        }
     }
 
+    /**
+     * Initializes the display of the Tournament list view
+     */
     public void openTournamentList() {
+        logger.fine("Showing TournamentList view");
         factory.showTournamentList((BorderPane) pane, this);
         informListener();
     }
 
-    public void openParticipantFormular() {
+    /**
+     * Initializes the view of the participant form
+     */
+    public void openParticipantForm() {
+        logger.fine("Showing participant form view");
         factory.showParticipantFormular((BorderPane) pane, this);
         informListener();
     }
 
-    public void openPlacesFormular() {
+    /**
+     * Initializes the view of the places form
+     */
+    public void openPlacesForm() {
+        logger.fine("Showing places form view");
         factory.showPlacesFormular((BorderPane) pane, this);
         informListener();
     }
@@ -109,7 +174,7 @@ public class FactoryDecorator implements IsObservable{
                     gameController.addListener(gameDecoratorsList.get(j * 2));
                     gameController.addListener(gameDecoratorsList.get(j * 2 + 1));
                 } else if (gameBoxHeight == 0) {
-                    gameBoxHeight = gameController.getGameBoxHeigth();
+                    gameBoxHeight = gameController.getGameBoxHeight();
                 }
                 gameDecorator.addListener(new IsObserver() {
                     @Override
@@ -158,15 +223,33 @@ public class FactoryDecorator implements IsObservable{
         return completeLineVBox;
     }
 
+    /**
+     * Method Initializes the Game View, in order to do that a vbox is needed and the gameDecorator
+     * @param vBox used for display
+     * @param gameDecorator
+     * @return
+     */
     public GameController openGameView(VBox vBox, GameDecorator gameDecorator) {
         return factory.loadGameView(vBox ,gameDecorator, this);
     }
 
+    /**
+     * Method that initializes a new Message to be written on the footer, if it's an error boolean can be set.
+     *
+     * @param msg The message to be written
+     * @param error true if an error false if not
+     */
     public void printMessageToFooter(String msg, boolean error) {
+        logger.fine("Initializes to write message: " + msg + " on the footer");
         factory.printMessageToFooter((BorderPane) pane, msg, error);
     }
 
+    /**
+     * Method used to clear Messages shown on the footer
+     * @param error true if an error false if not
+     */
     public void clearMessage(boolean error) {
+        logger.fine("Initializing to clear messages from the footer");
         factory.resetFooter((BorderPane) pane, error);
     }
 
@@ -174,6 +257,9 @@ public class FactoryDecorator implements IsObservable{
         return factory.getLanguageConfigurator();
     }
 
+    /**
+     * Method that informs all listeners of an update.
+     */
     public void informListener() {
         for(IsObserver observer : listener) {
             observer.update();

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FileIO.java

@@ -4,7 +4,14 @@ package ch.zhaw.projekt2.turnierverwaltung;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
 
-import java.io.*;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.net.URI;
 import java.util.logging.Logger;
 
@@ -12,8 +19,8 @@ import java.util.logging.Logger;
  * Class in Charge of Reading and Writing files
  */
 public class FileIO {
-    private File mainDir;
+    private final File mainDir;
-    private File saves;
+    private final File saves;
 
     private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
 
@@ -57,13 +64,14 @@ public class FileIO {
 
     /**
      * Method to check if a tournament with the existing name already exists.
+     *
      * @param name that is being checked
      * @return true if the name exists already false if the name is unique
      */
     public boolean tournamentExists(String name) {
         logger.finer("checking for duplicate name in tournament List");
         for (TournamentFile file : getList()) {
-            if (file.toString().toLowerCase().equals(name.toLowerCase())) {
+            if (file.toString().equalsIgnoreCase(name)) {
                 logger.fine(name + " is an already existing name in the list");
                 return true;
             }
@@ -73,10 +81,10 @@ public class FileIO {
     }
 
     /**
-     * Loads and returns a tournament from a given File which contains the serialiazed tournament.
+     * Loads and returns a tournament from a given File which contains the serialized tournament.
      *
      * @param tournamentFile The tournament file where the data should be read from.
-     * @return Tournament that is returned when succefully being read from the file
+     * @return Tournament that is returned when successfully being read from the file
      * @throws ClassNotFoundException No definition for the class with the specified name could be found
      * @throws IOException            File not readable
      * @throws FileNotFoundException  File not found
@@ -119,7 +127,7 @@ public class FileIO {
     }
 
     /**
-     * Serializables and saves the receiving tournament file to a txt file.
+     * Serializable and saves the receiving tournament file to a txt file.
      *
      * @param tournament the receiving tournament.
      * @throws IOException           File not readable
@@ -181,14 +189,14 @@ public class FileIO {
     }
 
     /**
-     * TournamentFile Class is in use to add missing functionality that is
+     * TournamentFile Class is in used to add missing functionality that is
      */
-    public class TournamentFile extends File {
+    public static class TournamentFile extends File {
 
         /**
          * Only job the constructor got is to initialize it via its superclass. See java.io.File Documentation for more info.
          *
-         * @param uri abstract pathname needed for its superclass to intialize the file accordingly.
+         * @param uri abstract pathname needed for its superclass to initialize the file accordingly.
          */
         public TournamentFile(URI uri) {
             super(uri);

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Game.java

@@ -1,77 +1,171 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
 import java.io.Serializable;
+import java.util.logging.Logger;
 
+/**
+ * Class Representing a game, implements Serializable to be saved inside a tournament
+ * Holding the data and points for a single match
+ */
 public class Game implements Serializable {
     private Participant participant1, participant2;
     private int points1, points2;
     private Place place;
     private Game previousGame1, previousGame2;
 
+    private static final Logger logger = Logger.getLogger(Game.class.getCanonicalName());
 
+    /**
+     * Constructor to initialize a new game.
+     * Two participants are needed.
+     *
+     * @param participant1 that is added to the game
+     * @param participant2 that is added to the game
+     */
     public Game(Participant participant1, Participant participant2) {
+        logger.fine("initializing a new game with the participants: " + participant1 + ", " + participant2);
         this.participant1 = participant1;
         this.participant2 = participant2;
     }
 
+    /**
+     * Constructor to initialize a game with two previous games.
+     *
+     * @param previousGame1 previous game (connecting to this game in the hierarchy)
+     * @param previousGame2 other previous game (connecting to this game in the hierarchy)
+     */
     public Game(Game previousGame1, Game previousGame2) {
+        logger.fine("initializing a new game with the previous games: " + previousGame1 + ", " + previousGame2);
         this.previousGame1 = previousGame1;
         this.previousGame2 = previousGame2;
     }
 
+    /**
+     * Method to get the points of the first participant
+     *
+     * @return points of participant 1
+     */
     public int getPoints1() {
+        logger.fine("Returning points of: " + participant1 + ", holding: " + points1 + " points");
         return points1;
     }
 
+    /**
+     * Method to set the points of the first participant
+     *
+     * @param points1 to be set for the first participant
+     */
     public void setPoints1(int points1) {
+        logger.fine("Setting points of: " + participant1 + ", to " + points1 + " points");
         this.points1 = points1;
     }
 
+    /**
+     * Method to get the points of the second participant
+     *
+     * @return points of participant 2
+     */
     public int getPoints2() {
+        logger.fine("Returning points of: " + participant2 + ", holding: " + points2 + " points");
         return points2;
     }
 
+    /**
+     * Method to set the points of the second participant
+     *
+     * @param points2 to be set for the second participant
+     */
     public void setPoints2(int points2) {
+        logger.fine("Setting points of: " + participant2 + ", to " + points2 + " points");
         this.points2 = points2;
     }
 
+    /**
+     * Method to get the first Participant
+     *
+     * @return the first Participant
+     */
     public Participant getParticipant1() {
+        logger.fine("Returning the first participant: " + participant1);
         return participant1;
     }
 
+    /**
+     * Method to set the first participant
+     *
+     * @param participant1 to be set as the first participant
+     */
     public void setParticipant1(Participant participant1) {
+        logger.fine("Setting the first Participant as: " + participant1);
         this.participant1 = participant1;
     }
 
+    /**
+     * Method to set the second participant
+     *
+     * @param participant2 to be set as the second participant
+     */
     public void setParticipant2(Participant participant2) {
+        logger.fine("Setting the second Participant as: " + participant2);
         this.participant2 = participant2;
     }
 
+    /**
+     * Method to get the second Participant
+     *
+     * @return the second participant
+     */
     public Participant getParticipant2() {
+        logger.fine("Returning the second participant: " + participant2);
         return participant2;
     }
 
+    /**
+     * Method to set the place of a game
+     *
+     * @param place to be set for the game
+     */
     public void setPlace(Place place) {
+        logger.fine("Setting the location of the game " + this + " to: " + place);
         this.place = place;
     }
 
+    /**
+     * Method to get the place of a game
+     *
+     * @return the place of the game
+     */
     public Place getPlace() {
+        logger.fine("Returning the place of the game, current Location: " + place);
         return place;
     }
 
+    /**
+     * Method to determine the winner of a game, if there is a draw null will be returned.
+     *
+     * @return the winner of the game or null if draw
+     */
     public Participant getWinner() {
+        logger.finer("Determining winner of game");
         if (points1 > points2) {
+            logger.fine(participant1 + "has won the game");
             return participant1;
         } else if (points2 > points1) {
+            logger.fine(participant2 + "has won the game");
             return participant2;
         } else {
+            logger.fine("There is no winner");
             return null;
         }
     }
 
+    /**
+     * Method that gets the winner of previous games and sets them as the participants of this game.
+     */
     public void refreshParticipants() {
         participant1 = previousGame1.getWinner();
         participant2 = previousGame2.getWinner();
+        logger.fine("Refreshed Participants, new Participants: " + participant1 + ", " + participant2);
     }
 
 }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/InvalidNameException.java

@@ -1,10 +1,15 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
+/**
+ * Invalid NameException is used to indicate when a given name does not follow the correct formatting.
+ */
 public class InvalidNameException extends Exception {
-    public InvalidNameException() {
+    /**
-        super();
+     * Constructor to throw the InvalidNameException, receives a String as input to define reason for throwing
-    }
+     * the error.
-
+     *
+     * @param errorMessage to be displayed with the exception
+     */
     public InvalidNameException(String errorMessage) {
         super(errorMessage);
     }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/IsObservable.java

@@ -2,18 +2,17 @@ package ch.zhaw.projekt2.turnierverwaltung;
 
 /**
  * Most basic interface for observing an object
- * @author bles
  *
+ * @author bles
  */
 public interface IsObservable {
     /**
      * Add an observer that listens for updates
-     * @param observer
      */
     void addListener(IsObserver observer);
+
     /**
      * Remove an observer from the list
-     * @param observer
      */
     void removeListener(IsObserver observer);
 }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/IsObserver.java

@@ -1,11 +1,12 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
 /**
- * Most basic interface for beeing an observer
+ * Most basic interface for being an observer
- * @author bles
  *
+ * @author bles
  */
 public interface IsObserver {
+
     /**
      * This method is always called when an observed object
      * changes

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/LogConfiguration.java

@@ -3,18 +3,30 @@ package ch.zhaw.projekt2.turnierverwaltung;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.logging.*;
+import java.util.logging.LogManager;
-
+import java.util.logging.Logger;
 
+/**
+ * Class in charge of setting up the Logging functionality properly
+ * For further Log settings look into the properties.log file
+ */
 public class LogConfiguration {
     private static final Logger logger = Logger.getLogger(LogConfiguration.class.getCanonicalName());
     private final File mainDir;
 
-    public LogConfiguration(String saveLocation, String logFileLocation) throws IOException {
+    /**
+     * Constructor of LogConfiguration, does the whole setup including reading the properties and setting up a
+     * directory for the log files also starts the root logger.
+     *
+     * @param saveLocation   where the log files should be placed in
+     * @param propertiesPath location of the properties.log file
+     * @throws IOException if error occurs while reading the log file
+     */
+    public LogConfiguration(String saveLocation, String propertiesPath) throws IOException {
         logger.fine("Starts setting up a main directory in which a folder with the log files will be placed, if not already exists");
         this.mainDir = new File(saveLocation);
         if (!mainDir.exists()) {
-            logger.fine("Creating main directory for log ordner in given path" + saveLocation);
+            logger.fine("Creating main directory for log folder in given path" + saveLocation);
             mainDir.mkdir();
         } else {
             logger.finer("main directory for log folder already exists");
@@ -25,15 +37,14 @@ public class LogConfiguration {
             saves.mkdir();
             logger.fine("Creating log save directory");
         } else {
-            logger.finer("log save directory already exists");
+            logger.finer("Log save directory already exists");
         }
 
-        String propertiesPath = "ch" + System.getProperty("file.separator") + "zhaw" + System.getProperty("file.separator") + "projekt2" + System.getProperty("file.separator") +
+        logger.fine("Getting and reading log config file from: " + propertiesPath);
-                "turnierverwaltung" + System.getProperty("file.separator") + "logging" + System.getProperty("file.separator") + "log.properties";
-
-        logger.fine("Getting and reading logconfig file from " + propertiesPath);
         InputStream logConfig = this.getClass().getClassLoader().getResourceAsStream(propertiesPath);
         LogManager.getLogManager().readConfiguration(logConfig);
+
         Logger.getLogger(LogConfiguration.class.getPackageName());
+        logger.fine("Finished setting up Logging functionality");
     }
 }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Person.java

@@ -14,7 +14,7 @@ public class Person implements Serializable {
     private String firstName;
     private String phoneNumber;
 
-    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
+    private static final Logger logger = Logger.getLogger(Person.class.getCanonicalName());
 
 
     /**

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Place.java

@@ -10,7 +10,7 @@ public class Place implements Serializable {
     private final String NAME_MATCHING_REGEX = "[a-zA-Z0-9]{1,20}";
     private String name;
 
-    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
+    private static final Logger logger = Logger.getLogger(Place.class.getCanonicalName());
 
     /**
      * Constructor of a place initializes it and checks if name is in valid format

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Player.java

@@ -12,7 +12,7 @@ public class Player extends Person implements Participant {
 
     private LocalDate dateOfBirth;
 
-    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
+    private static final Logger logger = Logger.getLogger(Player.class.getCanonicalName());
 
     /**
      * Constructor of player initializes a new player setting sever attributes like firstname, name birthdate usw.

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Team.java

@@ -13,7 +13,7 @@ public class Team implements Participant {
     private List<Player> players;
     private Person contactPerson;
 
-    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
+    private static final Logger logger = Logger.getLogger(Team.class.getCanonicalName());
 
     /**
      * Constructor to initiate a team, sets its name

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Tournament.java

@@ -22,7 +22,7 @@ public class Tournament implements Serializable {
     private final List<Place> places;
     private List<List<Game>> gameList;
 
-    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
+    private static final Logger logger = Logger.getLogger(Tournament.class.getCanonicalName());
 
 
     /**

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/TournamentDecorator.java

@@ -193,6 +193,7 @@ public class TournamentDecorator implements IsObservable{
         executorService.awaitTermination(2000, TimeUnit.MILLISECONDS);
     }
 
+
     private class saveTask implements Runnable {
 
         @Override

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindow.java

@@ -1,27 +1,37 @@
 package ch.zhaw.projekt2.turnierverwaltung.main;
 
-import ch.zhaw.projekt2.turnierverwaltung.*;
+import ch.zhaw.projekt2.turnierverwaltung.Factory;
+import ch.zhaw.projekt2.turnierverwaltung.FactoryDecorator;
+import ch.zhaw.projekt2.turnierverwaltung.FileIO;
+import ch.zhaw.projekt2.turnierverwaltung.TournamentDecorator;
 import javafx.application.Application;
-import javafx.event.EventHandler;
-import javafx.fxml.FXMLLoader;
 import javafx.scene.Scene;
 import javafx.scene.layout.BorderPane;
 import javafx.stage.Stage;
-import javafx.stage.WindowEvent;
-
 import java.util.logging.Logger;
 
-
+/**
+ * Class Main window is used to initialize the GUI Elements, Creating several Decorators and also getting the Factories
+ * ready
+ */
 public class MainWindow extends Application {
-    private FileIO fileIO = new FileIO(System.getProperty("user.dir") + System.getProperty("file.separator") + "tournierverwaltung_angrynerds");
+    private final FileIO fileIO = new FileIO(System.getProperty("user.dir") +
+            System.getProperty("file.separator") + "tournierverwaltung_angrynerds");
     private FactoryDecorator factoryDecorator;
     private TournamentDecorator tournamentDecorator = new TournamentDecorator(fileIO);
     private LanguageConfigurator languageConfigurator = new LanguageConfigurator();
     private Factory factory = new Factory(fileIO, tournamentDecorator, languageConfigurator);
     private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
 
+    /**
+     * Start method used to initialize the main window and load it's needed component
+     * Also sets the scene and set some values like min width and height
+     *
+     * @param primaryStage to be displayed
+     */
     @Override
     public void start(Stage primaryStage) throws Exception {
+        logger.fine("Starting up the main window with the primary Stage");
         BorderPane pane = factory.loadMainWindow();
         factoryDecorator = new FactoryDecorator(fileIO, factory, pane);
         factory.loadAllViews(factoryDecorator, pane);
@@ -39,6 +49,9 @@ public class MainWindow extends Application {
         primaryStage.show();
     }
 
+    /**
+     * Method used to safely shut down the application
+     */
     @Override
     public void stop() {
         try {

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindowController.java

@@ -8,7 +8,14 @@ import javafx.fxml.FXML;
 import javafx.scene.control.Label;
 import javafx.scene.control.Menu;
 import javafx.scene.control.MenuItem;
+import java.util.logging.Logger;
 
+
+/**
+ * Main WindowController Class in charge of the Controller Functions of it
+ * Since not much is directly in the main window only the top bar functionality is represented (language setting and
+ * close option).
+ */
 public class MainWindowController extends FXController {
 
     @FXML
@@ -20,18 +27,29 @@ public class MainWindowController extends FXController {
     @FXML
     private Menu menuItemLanguage;
 
+    private static final Logger logger = Logger.getLogger(MainWindowController.class.getCanonicalName());
+
+    /**
+     * Method changes the language Setting to german
+     */
     @FXML
     void changeLangToGerman(ActionEvent event) {
         getLanguageConfigurator().changeLanguage(LanguageConfigurator.Language.GERMAN);
+        logger.fine("language setting changed to german");
     }
 
     @FXML
     void changeLangToEnglish(ActionEvent event) {
         getLanguageConfigurator().changeLanguage(LanguageConfigurator.Language.ENGLISH);
+        logger.fine("language setting changed to english");
     }
 
+    /**
+     * This Method initializes the
+     */
     @FXML
-    void closeApplication(ActionEvent event) {
+    void closeApplication() {
+        logger.fine("");
         Platform.exit();
     }
 
@@ -43,7 +61,9 @@ public class MainWindowController extends FXController {
     }
 
 
-
+    /**
+     * There is no content to load
+     */
     @Override
     public void loadContent() {
 

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/AlertNewSchedule.java

@@ -1,9 +1,17 @@
 package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
 
+import ch.zhaw.projekt2.turnierverwaltung.LanguageConfigurator;
+import javafx.scene.control.Alert;
+import javafx.scene.control.ButtonBar;
+package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
+
 import ch.zhaw.projekt2.turnierverwaltung.LanguageConfigurator;
 import javafx.scene.control.Alert;
 import javafx.scene.control.ButtonBar;
 import javafx.scene.control.ButtonType;
+/**
+ * Class that is used to display the popup window to confirm a sensitive action of the user.
+ */
 
 public class AlertNewSchedule extends Alert {
     private ButtonType yesButton;
@@ -15,6 +23,9 @@ public class AlertNewSchedule extends Alert {
     private String headerDelete;
     private String contentDelete;
 
+    /**
+     * Popup to ask the user if he is sure that he wants to reshuffle the game board.
+     */
     public AlertNewSchedule(LanguageConfigurator languageConfigurator){
         super(Alert.AlertType.WARNING);
         yes = languageConfigurator.getSelectedLanguage("yes");
@@ -30,6 +41,11 @@ public class AlertNewSchedule extends Alert {
         getButtonTypes().setAll(yesButton, noButton);
     }
 
+    /**
+     * Result gathered from previous question popup window
+     *
+     * @return boolean true if yes button is pressed and false if no is pressed
+     */
     public boolean showAndGetResult() {
         showAndWait().ifPresent(input -> {
             result = input == yesButton;

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameController.java

@@ -10,6 +10,9 @@ import javafx.scene.control.TextField;
 import javafx.scene.layout.Pane;
 import javafx.scene.layout.VBox;
 
+/**
+ * Class GameController in Charge of the Controller Element of the Schedule view.
+ */
 public class GameController extends FXController{
 
     private GameDecorator gameDecorator;
@@ -41,7 +44,7 @@ public class GameController extends FXController{
     }
 
     @FXML
-    void saveGameResult(Event event) {
+    void saveGameResult() {
         gameDecorator.saveGameResult(pointsTeamOne.getText(), pointsTeamTwo.getText());
     }
 
@@ -50,7 +53,7 @@ public class GameController extends FXController{
         gameDecorator.saveGamePlace(newPlace);
     }
 
-    public double getGameBoxHeigth(){
+    public double getGameBoxHeight(){
         return mainVBox.getPrefHeight();
     }
 

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameScheduleController.java

@@ -51,12 +51,12 @@ public class GameScheduleController extends FXController {
 
     @FXML
     void openPlacesFormular(ActionEvent event) {
-        getFactoryDecorator().openPlacesFormular();
+        getFactoryDecorator().openPlacesForm();
     }
 
     @FXML
     void openParticipantFormular(ActionEvent event) {
-        getFactoryDecorator().openParticipantFormular();
+        getFactoryDecorator().openParticipantForm();
     }
 
     @FXML

app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/FileIOTest.java

@@ -1,6 +1,6 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
-import org.junit.jupiter.api.Assertions;
+
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -12,10 +12,13 @@ import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.Comparator;
 import java.util.List;
-import java.util.logging.Logger;
+
 
 import static org.junit.jupiter.api.Assertions.*;
 
+/**
+ * FileIO Test Class
+ */
 class FileIOTest {
 
     String RESOURCES_DIR = "./src/test/resources/ch/zhaw/projekt2/turnierverwaltung/";
@@ -23,6 +26,11 @@ class FileIOTest {
     String saveDir;
     FileIO io;
 
+    /**
+     * Method checks if a new directory is set up correctly and can be accessed.
+     *
+     * @throws IOException Exceptions should not be thrown
+     */
     @Test
     void FileIONewDir() throws IOException {
         mainDir = RESOURCES_DIR + "FileIONew";
@@ -50,14 +58,23 @@ class FileIOTest {
         assertFalse(saveDirFile.exists());
     }
 
+    /**
+     * Method tests the read behavior and if a file is read correctly
+     */
     @Nested
     class Read{
+        /**
+         *  Sets up a directory
+         */
         @BeforeEach
         void init() {
             mainDir = RESOURCES_DIR + "FileIORead";
             io = new FileIO(mainDir);
         }
 
+        /**
+         * Test if the list is displayed correctly when getting it via getList
+         */
         @Test
         void getList() {
             List<FileIO.TournamentFile> tournaments = io.getList();
@@ -65,6 +82,9 @@ class FileIOTest {
             assertEquals("test1.txt", tournaments.get(1).getName());
         }
 
+        /**
+         * Test behaviour when the list is empty
+         */
         @Test
         void getListEmpty() {
             mainDir = RESOURCES_DIR + "FileIOEmpty";
@@ -72,6 +92,12 @@ class FileIOTest {
             assertEquals(0, io.getList().size());
         }
 
+        /**
+         * Tests behavior when loading a tournament that exists.
+         *
+         * @throws IOException Exceptions should not be thrown
+         * @throws ClassNotFoundException Exceptions should not be thrown
+         */
         @Test
         void loadTournament() throws IOException, ClassNotFoundException {
             mainDir = RESOURCES_DIR + "FileIORead";
@@ -80,6 +106,9 @@ class FileIOTest {
             assertEquals("test1", tournament.getName());
         }
 
+        /**
+         * Test behavior when trying to load non-existent tournament
+         */
         @Test
         void loadTournamentNotExisting(){
             File file = new File("Not-existing-File");
@@ -88,11 +117,17 @@ class FileIOTest {
             assertFalse(file.exists());
         }
 
+        /**
+         * Tests behavior when trying to load an empty tournament.
+         */
         @Test
         void loadTournamentEmpty(){
             assertThrows(IOException.class, () -> io.loadTournament(new File(mainDir + "/saves/empty.txt")));
         }
 
+        /**
+         * Tests behavior when the tournamentfile input is null
+         */
         @Test
         void loadTournamentFileNull(){
             assertThrows(IllegalArgumentException.class, () -> io.loadTournament(null));
@@ -107,6 +142,13 @@ class FileIOTest {
             io = new FileIO(mainDir);
         }
 
+        /**
+         * Saves the Saving mechanism and deletion
+         *
+         * @throws IOException Exceptions should not be thrown
+         * @throws InvalidNameException Exceptions should not be thrown
+         * @throws Tournament.InvalidTypeException Exceptions should not be thrown
+         */
         @Test
         void saveTournament() throws IOException, InvalidNameException, Tournament.InvalidTypeException {
             Tournament tournament = null;
@@ -118,6 +160,9 @@ class FileIOTest {
             assertFalse(file.exists());
         }
 
+        /**
+         * Tests behavior when a tournament is being saved that is only null
+         */
         @Test
         void saveTournamentNull(){
             assertThrows(IllegalArgumentException.class, () -> io.saveTournament(null));
@@ -132,6 +177,10 @@ class FileIOTest {
             io = new FileIO(mainDir);
         }
 
+        /**
+         *  Test if tournament that does exist can be deleted
+         * @throws IOException Exceptions should not be thrown
+         */
         @Test
         void deleteTournament() throws IOException {
             File file = new File(mainDir + "/saves/test1.txt");
@@ -141,6 +190,11 @@ class FileIOTest {
             assertFalse(file.exists());
         }
 
+        /**
+         * Testing if tournament that does not exist can be deleted
+         *
+         * @throws IOException Exception should not be thrown only checking for FileNotFoundException
+         */
         @Test
         void deleteTournamentNotExisting() throws IOException {
             File file = new File("Not-existing-File");
@@ -149,6 +203,9 @@ class FileIOTest {
             assertFalse(file.exists());
         }
 
+        /**
+         * Tests if a tournament that is null can be deleted
+         */
         @Test
         void deleteTournamentNull(){
             assertThrows(IllegalArgumentException.class, () -> io.deleteTournament(null));