javadocs in TournamentDecorator.java

Logging and docs added in several classes #27 #28

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",
-                    "ch" + System.getProperty("file.separator") + "zhaw" + System.getProperty("file.separator") + "projekt2" + System.getProperty("file.separator") +
-                    "turnierverwaltung" + System.getProperty("file.separator") + "logging" + System.getProperty("file.separator") + "log.properties");
+            new LogConfiguration(System.getProperty("user.dir") + System.getProperty("file.separator") +
+                    "tournierverwaltung_angrynerds", "ch" + System.getProperty("file.separator") + "zhaw" +
+                    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/FXController.java

@@ -8,8 +8,9 @@ public abstract class FXController {
     FileIO fileIO;
     Pane pane;
     IsObserver listener;
+    LanguageConfigurator languageConfigurator;
 
-    public FXController(){
+    public FXController() {
         listener = new IsObserver() {
             @Override
             public void update() {
@@ -18,21 +19,30 @@ public abstract class FXController {
         };
     }
 
-    public void setup(TournamentDecorator tournamentDecorator, FileIO fileIO, FactoryDecorator factoryDecorator, Pane pane){
+    public void setup(LanguageConfigurator languageConfigurator) {
+        this.languageConfigurator = languageConfigurator;
+        shareGUIElementWithLanguageConfigurator();
+    }
+
+    public void setup(TournamentDecorator tournamentDecorator, FileIO fileIO, FactoryDecorator factoryDecorator, Pane pane, LanguageConfigurator languageConfigurator) {
         this.tournamentDecorator = tournamentDecorator;
         this.fileIO = fileIO;
         this.factoryDecorator = factoryDecorator;
         this.pane = pane;
+        this.languageConfigurator = languageConfigurator;
+        shareGUIElementWithLanguageConfigurator();
         addListener();
     }
 
+    public abstract void shareGUIElementWithLanguageConfigurator();
+
     public abstract void loadContent();
 
     protected void setTournamentDecorator(TournamentDecorator tournamentDecorator) {
         this.tournamentDecorator = tournamentDecorator;
     }
 
-    public void addListener(){
+    public void addListener() {
         tournamentDecorator.addListener(listener);
         factoryDecorator.addListener(listener);
     }
@@ -64,4 +74,8 @@ public abstract class FXController {
     protected Pane getPane() {
         return pane;
     }
+
+    protected LanguageConfigurator getLanguageConfigurator() {
+        return languageConfigurator;
+    }
 }

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

@@ -10,88 +10,149 @@ import javafx.scene.paint.Color;
 import javafx.scene.text.Font;
 
 import java.io.IOException;
+import java.util.logging.Logger;
 
+/**
+ * Class to load the views from FXML Files and switch between the views.
+ */
 public class Factory {
     private TournamentDecorator tournamentDecorator;
     private FileIO fileIO;
+    private static LanguageConfigurator languageConfigurator;
 
-    public Factory(FileIO fileIO, TournamentDecorator tournamentDecorator) {
+    private static final Logger logger = Logger.getLogger(Factory.class.getCanonicalName());
+
+    /**
+     * Contructor to create Factory instance.
+     * @param fileIO the fileIO instance which saves and reads the tournament from files.
+     * @param tournamentDecorator the touramanetDecorator class to access the tournament.
+     */
+    public Factory(FileIO fileIO, TournamentDecorator tournamentDecorator, LanguageConfigurator languageConfigurator) {
         this.fileIO = fileIO;
         this.tournamentDecorator = tournamentDecorator;
-
-    }
-
-    public TournamentDecorator getTournamentDecorator() {
-        return tournamentDecorator;
+        this.languageConfigurator = languageConfigurator;
     }
 
+    /**
+     * Setter Method of tournament
+     * @param tournament the new tournament Object.
+     */
     public void setTournament(Tournament tournament) {
         this.tournamentDecorator.setTournament(tournament);
     }
 
+    /**
+     * Method to load the main Window (without the content in the center)
+     * @return the boarder Pane which is loaded.
+     */
     public BorderPane loadMainWindow() {
-        FXMLLoader loader = new FXMLLoader(getClass().getResource("mainWindow.fxml"));
+        FXMLLoader loader = new FXMLLoader(getClass().getResource("MainWindow.fxml"));
         try {
-            return loader.load();
+            BorderPane pane = loader.load();
+            FXController controller = loader.getController();
+            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;
     }
 
+    /**
+     * Class which loads all views of Enum View
+     * @param factoryDecorator the FactoryDecorator which is used to setup the controller.
+     * @param pane the pane where the loaded view will be visible
+     */
     public void loadAllViews(FactoryDecorator factoryDecorator, BorderPane pane){
         for(View view : View.values()){
             try {
                 view.loadView(tournamentDecorator, fileIO, factoryDecorator, pane);
             } catch (IOException e) {
                 e.printStackTrace();
-                //TODO Handle and logging.
+                logger.warning("failed to load views.");
             }
         }
     }
 
-    public void showTournamentList(BorderPane pane, FactoryDecorator factoryDecorator) {
+    /**
+     * Method to show the view TournamentList
+     * @param pane the Pane where the View will be visible
+     */
+    public void showTournamentList(BorderPane pane) {
         tournamentDecorator.setTournament(null);
         setCenterOfBorderPane(pane, View.tournamentList);
+        logger.fine("showing Tournament List");
     }
 
-    //Can be used to Open new Scene in same Stage.
-    //This way possible to later give object to Controller
-    public void showParticipantFormular(BorderPane pane, FactoryDecorator factoryDecorator) {
+    /**
+     * Method to show the view ParticipantFormular
+     * @param pane the Pane where the View will be visible
+     */
+    public void showParticipantFormular(BorderPane pane) {
         setCenterOfBorderPane(pane, View.participantFormular);
+        logger.fine("showing Participant Formular");
     }
 
-    public void showPlacesFormular(BorderPane pane, FactoryDecorator factoryDecorator) {
+    /**
+     * Method to show the view PlacesFormular
+     * @param pane the Pane where the View will be visible
+     */
+    public void showPlacesFormular(BorderPane pane) {
         setCenterOfBorderPane(pane, View.placesFormular);
+        logger.fine("showing Places Formular");
     }
 
-    public void showGameScheduler(BorderPane pane, FactoryDecorator factoryDecorator) {
+    /**
+     * Method to show the view GameScheduler
+     * @param pane the Pane where the View will be visible
+     */
+    public void showGameScheduler(BorderPane pane) {
         setCenterOfBorderPane(pane, View.gameScheduler);
+        logger.fine("showing Game Scheduler");
     }
 
+    /**
+     * Method to change the view in the center of the boarder pane in the mainWindow
+     * @param pane the Pane where the View will be visible
+     * @param view the view which should be visible
+     */
     private void setCenterOfBorderPane(BorderPane pane, View view) {
         FXController controller = null;
         pane.setCenter(view.getPane());
         resetFooter(pane, true);
     }
 
-
+    /**
+     * Method to load a Game View
+     * @param box the box where the game view should be added.
+     * @param gameDecorator the gameDecorator instance of the game.
+     * @param factoryDecorator the factoryDecorator instance.
+     * @return the controller of the GameView
+     */
     public GameController loadGameView(VBox box, GameDecorator gameDecorator, FactoryDecorator factoryDecorator) {
         try {
             FXMLLoader loader = new FXMLLoader(getClass().getResource("gameScheduleView/Game.fxml"));
             box.getChildren().add(loader.load());
             GameController controller = loader.getController();
-            controller.setup(tournamentDecorator, fileIO, factoryDecorator, box, gameDecorator);
+            controller.setup(tournamentDecorator, fileIO, factoryDecorator, box, gameDecorator, languageConfigurator);
+            logger.fine("loaded game view");
             return controller;
         } catch (IOException e) {
+            logger.warning("Fatal error program can not continue after this: " + e );
             e.printStackTrace();
-            //TODO LOGGER
         }
         return null;
     }
 
+    /**
+     * Method to print information for the user to the footer of mainwindow.
+     * @param pane the pane where the footer should be shown.
+     * @param msg the text to show.
+     * @param error true if it's a error message.
+     */
     public void printMessageToFooter(BorderPane pane, String msg, boolean error) {
+        logger.fine("message is printed to footer of window.");
         VBox bottom = (VBox) pane.getBottom();
         Label label = new Label();
         VBox innerVbox;
@@ -118,7 +179,13 @@ public class Factory {
 
     }
 
+    /**
+     * Method to remove the messages in the footer.
+     * @param pane the pane were the footer should be reseted
+     * @param error true if the error message should be cleared.
+     */
     public void resetFooter(BorderPane pane,boolean error) {
+        logger.fine("messages are removed from footer of window.");
         VBox bottom = (VBox) pane.getBottom();
         VBox vBox;
         if (error) {
@@ -130,6 +197,14 @@ public class Factory {
         vBox.setBorder(null);
     }
 
+
+    public LanguageConfigurator getLanguageConfigurator() {
+        return languageConfigurator;
+    }
+
+      /**
+     * Enum of all views which can be set to the center of the mainwindow.
+     */
     public enum View {
         tournamentList("tournamentList/tournamentList.fxml"),
         participantFormular("participantAddFormular/participantFormular.fxml"),
@@ -139,6 +214,10 @@ public class Factory {
         private String fxmlFileName;
         private Pane pane;
 
+        /**
+         * Constructor of View
+         * @param fxmlFileName The name of the FXML File to load.
+         */
         private View(String fxmlFileName) {
             this.fxmlFileName = fxmlFileName;
         }
@@ -147,11 +226,19 @@ public class Factory {
             return pane;
         }
 
+        /**
+         * Method to laod the view
+         * @param tournamentDecorator the tournamentDecorator object which will be passed to the controller.
+         * @param fileIO the fileIO object which will be passed to the controller.
+         * @param factoryDecorator the factoryDecorator object which will be passed to the controller.
+         * @param borderPane the borderPane object which will be passed to the controller.
+         * @throws IOException if the fxml file is not found or can not be loaded correctly.
+         */
         public void loadView(TournamentDecorator tournamentDecorator, FileIO fileIO, FactoryDecorator factoryDecorator, BorderPane borderPane) throws IOException {
             FXMLLoader loader = new FXMLLoader(getClass().getResource(fxmlFileName));
             this.pane = loader.load();
             FXController controller = loader.getController();
-            controller.setup(tournamentDecorator, fileIO, factoryDecorator, borderPane);
+            controller.setup(tournamentDecorator, fileIO, factoryDecorator, borderPane, languageConfigurator);
         }
 
     }

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

@@ -12,76 +12,152 @@ import javafx.scene.shape.Line;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.logging.Logger;
 
-public class FactoryDecorator implements IsObservable{
+/**
+ * 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<>();
 
-    public FactoryDecorator(FileIO fileIO, Factory factory, Pane pane){
+    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);
     }
 
-    public void openTournament(FileIO.TournamentFile tournamentFile){
+    /**
+     * 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();
+            logger.warning("Failed to open tournament file Error: " + e);
             printMessageToFooter("Fehler beim lesen der Datei.", true);
-        }  //TODO handle and logging
+            String msg = factory.getLanguageConfigurator().getSelectedLanguage("IOException");
+            printMessageToFooter(msg, true);
+        }
     }
 
+    /**
+     * Initializes the display of the Tournament list view
+     */
     public void openTournamentList() {
-        factory.showTournamentList((BorderPane) pane, this);
+        logger.fine("Showing TournamentList view");
+        factory.showTournamentList((BorderPane) pane);
         informListener();
     }
 
-    public void openParticipantFormular() {
-        factory.showParticipantFormular((BorderPane) pane, this);
+    /**
+     * Initializes the view of the participant form
+     */
+    public void openParticipantForm() {
+        logger.fine("Showing participant form view");
+        factory.showParticipantFormular((BorderPane) pane);
         informListener();
     }
 
-    public void openPlacesFormular() {
-        factory.showPlacesFormular((BorderPane) pane, this);
+    /**
+     * Initializes the view of the places form
+     */
+    public void openPlacesForm() {
+        logger.fine("Showing places form view");
+        factory.showPlacesFormular((BorderPane) pane);
         informListener();
     }
 
+    /**
+     * Initializes the view of gameSchedule
+     */
     public void openScheduleView() {
-        factory.showGameScheduler((BorderPane) pane, this);
+        factory.showGameScheduler((BorderPane) pane);
         informListener();
     }
 
+    /**
+     * Method to load all game views to show.
+     * @param hBoxCenter the box where the games should be shown.
+     * @param tournamentDecorator the tournamentDecorator to communicate to tournament
+     * @param treeView true if the games should be arranged like a tree.
+     */
     public void loadGameList(HBox hBoxCenter, TournamentDecorator tournamentDecorator, boolean treeView) {
         hBoxCenter.getChildren().clear();
 
-        if(tournamentDecorator.getTournament() == null){
+        if (tournamentDecorator.getTournament() == null) {
             return;
         }
 
@@ -93,7 +169,7 @@ public class FactoryDecorator implements IsObservable{
         for (int i = 0; i < gameList.size(); i++) {
             List<GameDecorator> newGameDecoratorsList = new ArrayList<>();
             VBox vBox = new VBox();
-            if(treeView){
+            if (treeView) {
                 vBox.setAlignment(Pos.CENTER);
                 vBox.setSpacing(gameBoxHeight * spacingFactor);
             } else {
@@ -103,12 +179,12 @@ public class FactoryDecorator implements IsObservable{
             for (int j = 0; j < gameList.get(i).size(); j++) {
                 GameDecorator gameDecorator = new GameDecorator(gameList.get(i).get(j));
                 newGameDecoratorsList.add(gameDecorator);
-                GameController gameController = openGameView(vBox,gameDecorator);
-                if(i>0){
-                    gameController.addListener(gameDecoratorsList.get(j*2));
-                    gameController.addListener(gameDecoratorsList.get(j*2+1));
-                } else if(gameBoxHeight == 0) {
-                    gameBoxHeight = gameController.getGameBoxHeigth();
+                GameController gameController = openGameView(vBox, gameDecorator);
+                if (i > 0) {
+                    gameController.addListener(gameDecoratorsList.get(j * 2));
+                    gameController.addListener(gameDecoratorsList.get(j * 2 + 1));
+                } else if (gameBoxHeight == 0) {
+                    gameBoxHeight = gameController.getGameBoxHeight();
                 }
                 gameDecorator.addListener(new IsObserver() {
                     @Override
@@ -119,28 +195,35 @@ public class FactoryDecorator implements IsObservable{
                 gameController.loadContent();
             }
             hBoxCenter.getChildren().add(vBox);
-            if(treeView){
-                if(i+1 < gameList.size())
-                hBoxCenter.getChildren().add(drawLines(vBox, gameBoxHeight, 30));
+            if (treeView) {
+                if (i + 1 < gameList.size())
+                    hBoxCenter.getChildren().add(drawLines(vBox, gameBoxHeight, 30));
             }
             gameDecoratorsList = newGameDecoratorsList;
         }
     }
 
-    public VBox drawLines(VBox gameVBox, double gameBoxHeight, double lineLength){
+    /**
+     * Method to draw the lines between the game views in the tree view.
+     * @param gameVBox the box with the games where lines should be drawn.
+     * @param gameBoxHeight the heigth of a single game box.
+     * @param lineLength the length of the horizontal lines.
+     * @return a box which contains the drawn lines.
+     */
+    public VBox drawLines(VBox gameVBox, double gameBoxHeight, double lineLength) {
         VBox completeLineVBox = new VBox();
         completeLineVBox.setAlignment(Pos.CENTER_LEFT);
         double lineSpacing = gameVBox.getSpacing() + gameBoxHeight - 1;
         completeLineVBox.setSpacing(lineSpacing);
-        for(int i = 0; i < gameVBox.getChildren().size(); i+=2){
+        for (int i = 0; i < gameVBox.getChildren().size(); i += 2) {
             HBox lineBox = new HBox();
             lineBox.setAlignment(Pos.CENTER);
 
             //add Lines from left Game to center
             VBox vBox = new VBox();
             vBox.setSpacing(lineSpacing);
-            vBox.getChildren().add(new Line(0,0,lineLength,0));
-            vBox.getChildren().add(new Line(0,0,lineLength,0));
+            vBox.getChildren().add(new Line(0, 0, lineLength, 0));
+            vBox.getChildren().add(new Line(0, 0, lineLength, 0));
             lineBox.getChildren().add(vBox);
 
 
@@ -157,20 +240,51 @@ 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 the gameDecorator Object to communicate with game
+     * @return the controller of the loaded game view.
+     */
     public GameController openGameView(VBox vBox, GameDecorator gameDecorator) {
-        return factory.loadGameView(vBox ,gameDecorator, this);
+
+        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) {
-        factory.printMessageToFooter((BorderPane) pane,msg,error);
+        logger.fine("Initializes to write message: " + msg + " on the footer");
+        factory.printMessageToFooter((BorderPane) pane, msg, error);
     }
 
-    public void clearMessage(boolean 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);
     }
 
+    /**
+     * getter Method of languageConfigurator
+     * @return the languageConfigurator object.
+     */
+    public LanguageConfigurator getLanguageConfigurator() {
+        return factory.getLanguageConfigurator();
+    }
+
+    /**
+     * Method that informs all listeners of an update.
+     */
     public void informListener() {
-        for(IsObserver observer : listener) {
+
+        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 File saves;
+    private final File mainDir;
+    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;
     }
 
-    public Game(Game previousGame1, Game previousGame2){
+    /**
+     * 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;
     }
 
-    public Participant getWinner(){
-        if(points1 > points2){
+    /**
+     * 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){
+        } else if (points2 > points1) {
+            logger.fine(participant2 + "has won the game");
             return participant2;
         } else {
+            logger.fine("There is no winner");
             return null;
         }
     }
 
-    public void refreshParticipants(){
+    /**
+     * 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
- * @author bles
+ * Most basic interface for being an observer
  *
+ * @author bles
  */
 public interface IsObserver {
+
     /**
      * This method is always called when an observed object
      * changes

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

@@ -0,0 +1,196 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import javafx.scene.control.Labeled;
+import javafx.scene.control.MenuItem;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class LanguageConfigurator {
+
+    private Language selectedLanguage;
+    private Map<String,String> germanDictionary;
+    private Map<String,String> englishDictionary;
+    private List<Labeled> labelList;
+    private List<MenuItem> menuItemList;
+
+    public LanguageConfigurator() {
+        selectedLanguage = Language.GERMAN;
+        labelList = new ArrayList<>();
+        menuItemList = new ArrayList<>();
+        germanDictionary = new HashMap<>();
+        englishDictionary = new HashMap<>();
+        setUpDictionaries();
+    }
+
+    private void setUpDictionaries() {
+        //Main
+        germanDictionary.put("menuItemLanguage","Sprache");
+        englishDictionary.put("menuItemLanguage","Language");
+        germanDictionary.put("closeBtn","Beenden");
+        englishDictionary.put("closeBtn","Close");
+        germanDictionary.put("mainTitle","Turnier Manager");
+        englishDictionary.put("mainTitle","Tournament Manager");
+        //Tournamentlist
+        germanDictionary.put("tournamentListTitle","Bestehende Turniere");
+        englishDictionary.put("tournamentListTitle","Existing tournaments");
+        germanDictionary.put("openBtn","Oeffnen");
+        englishDictionary.put("openBtn","Open");
+        germanDictionary.put("deleteBtn","Loeschen");
+        englishDictionary.put("deleteBtn","Delete");
+        germanDictionary.put("newTournamentFormularTitle","Neues Turnier erstellen");
+        englishDictionary.put("newTournamentFormularTitle","Create new tournament");
+        germanDictionary.put("tournamentNameLabel","Turnier Name:");
+        englishDictionary.put("tournamentNameLabel","Tournament Name:");
+        germanDictionary.put("tournamentModLabel","Turnier Modus:");
+        englishDictionary.put("tournamentModLabel","Tournament Mode:");
+        germanDictionary.put("createBtn","Erstellen");
+        englishDictionary.put("createBtn","Create");
+        //PlaceList
+        germanDictionary.put("placeListTitle","Hinzugefuegt");
+        englishDictionary.put("placeListTitle","Added");
+        germanDictionary.put("saveBtn","Speichern");
+        englishDictionary.put("saveBtn","Save");
+        germanDictionary.put("newPlaceTitle","Ort aendern/erstellen");
+        englishDictionary.put("newPlaceTitle","Create/Change Location");
+        germanDictionary.put("placeNameLabel","Ort:");
+        englishDictionary.put("placeNameLabel","Location:");
+        //GameSchedule
+        germanDictionary.put("treeView","Baumansicht");
+        englishDictionary.put("treeView","Treeview");
+        germanDictionary.put("createScheduleBtn","Spielplan erstellen");
+        englishDictionary.put("createScheduleBtn","Create game schedule");
+        germanDictionary.put("editParticipantBtn","Teilnehmer bearbeiten");
+        englishDictionary.put("editParticipantBtn","Edit Participants");
+        germanDictionary.put("editLocBtn","Orte bearbeiten");
+        englishDictionary.put("editLocBtn","Edit Locations");
+        germanDictionary.put("closeTournamentBtn","Turnier schliessen");
+        englishDictionary.put("closeTournamentBtn","Close tournament");
+        //ParticipantFormular
+        germanDictionary.put("participantListTitle","Hinzugefuegt");
+        englishDictionary.put("participantListTitle","Added");
+        germanDictionary.put("newParticipantFormularTitle","Teilnehmer aendern/erstellen");
+        englishDictionary.put("newParticipantFormularTitle","Change/Create Participant");
+        germanDictionary.put("participantNameLabel","Name:");
+        englishDictionary.put("participantNameLabel","Name:");
+        germanDictionary.put("firstNameLabel","Vorname:");
+        englishDictionary.put("firstNameLabel","First Name:");
+        germanDictionary.put("phoneNumberLabel","Telefon:");
+        englishDictionary.put("phoneNumberLabel","Phone:");
+        germanDictionary.put("birthDateLabel","Geb. Datum:");
+        englishDictionary.put("birthDateLabel","Birthdate:");
+        //Game
+        germanDictionary.put("locationLabel","Ort:");
+        englishDictionary.put("locationLabel","Location:");
+        //Error
+        germanDictionary.put("IOException","Fehler beim lesen der Datei");
+        englishDictionary.put("IOException","Could not read file");
+        germanDictionary.put("tournamentExists","Turniername vergeben");
+        englishDictionary.put("tournamentExists","Tournament exists already");
+        germanDictionary.put("invalidName","Name nicht gueltig");
+        englishDictionary.put("invalidName","Name not valid");
+        germanDictionary.put("invalidMode","Modus nicht gueltig");
+        englishDictionary.put("invalidMode","Mode not valid");
+        germanDictionary.put("numberParticipant","Anzahl Spieler muss mindestens 4 sein und eine Potenz von 2");
+        englishDictionary.put("numberParticipant","Number of players must be greater than 3 and power of 2");
+        germanDictionary.put("invalidPhone","Telefonnummer nicht gueltig");
+        englishDictionary.put("invalidPhone","Phonenumber not valid");
+        germanDictionary.put("invalidDate","Geburtsdatum nicht gueltig");
+        englishDictionary.put("invalidDate","Birthdate not valid");
+        germanDictionary.put("participantNotExist","Teilnehmer existiert nicht");
+        englishDictionary.put("participantNotExist","Participant does not exist");
+        germanDictionary.put("placeNotExist","Teilnehmer existiert nicht");
+        englishDictionary.put("placeNotExist","Participant does not exist");
+
+        //SaveMsg
+        germanDictionary.put("save","Zuletzt gespeichert: ");
+        englishDictionary.put("save","Last saved: ");
+
+        //Alert
+        germanDictionary.put("yes","Ja");
+        englishDictionary.put("yes","Yes");
+        germanDictionary.put("no","Nein");
+        englishDictionary.put("no","No");
+        germanDictionary.put("titleDelete","Entfernen");
+        englishDictionary.put("titleDelete","Remove");
+        germanDictionary.put("headerDelete","Turnier entfernen?");
+        englishDictionary.put("headerDelete","Delete Tournament?");
+        germanDictionary.put("contentDelete","Sind Sie sicher, dass sie das Turnier entfernen wollen?\nNach diesem Vorgang kann es nicht wiederhergestellt werden.");
+        englishDictionary.put("contentDelete","Are you shure you want to delete the tournament?\nAfter that there is no way to restore.");
+
+        germanDictionary.put("titleSchedule","Neu erstellen");
+        englishDictionary.put("titleSchedule","Create new");
+        germanDictionary.put("headerSchedule","Spielplan neu erstellen?");
+        englishDictionary.put("headerSchedule","Create new Schedule?");
+        germanDictionary.put("contentSchedule","Sind Sie sicher, dass Sie den Spielplan neu erstellen moechten?\nAlle Spielfortschritte gehen daraufhin verloren!");
+        englishDictionary.put("contentSchedule","Are you shure you want to create a new game schedule?\nAll results will be lost!");
+    }
+
+    public void translateGUI() {
+        String word = "";
+        for (Labeled label : labelList) {
+            switch (selectedLanguage) {
+                case GERMAN -> {
+                    word = germanDictionary.get(label.getId());
+                }
+                case ENGLISH -> {
+                    word = englishDictionary.get(label.getId());
+                }
+            }
+            if(word != null) {
+                label.setText(word);
+            } else {
+                //TODO LOG
+            }
+        }
+
+        for (MenuItem item : menuItemList) {
+            switch (selectedLanguage) {
+                case GERMAN -> {
+                    word = germanDictionary.get(item.getId());
+                }
+                case ENGLISH -> {
+                    word = englishDictionary.get(item.getId());
+                }
+            }
+            if(word != null) {
+                item.setText(word);
+            } else {
+                //TODO LOG
+            }
+        }
+    }
+
+    public void recieveLabel(Labeled label) {
+        if (label != null) {
+            labelList.add(label);
+        }
+    }
+
+    public void recieveMenuItem(MenuItem item) {
+        menuItemList.add(item);
+    }
+
+    public void changeLanguage(Language language) {
+        this.selectedLanguage = language;
+        translateGUI();
+    }
+
+    public String getSelectedLanguage(String getMsg) {
+        String word = "";
+        switch (selectedLanguage) {
+            case GERMAN -> word = germanDictionary.getOrDefault(getMsg,"check Logs");
+            case ENGLISH -> word = englishDictionary.getOrDefault(getMsg,"check Logs");
+        }
+        if (word.equals("check Logs")) {
+            //TODO Log
+        }
+        return word;
+    }
+
+    public enum Language {
+        ENGLISH,GERMAN
+    }
+}

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,17 +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") +
-                "turnierverwaltung" + System.getProperty("file.separator") + "logging" + System.getProperty("file.separator") + "log.properties";
-
-        logger.fine("Getting and reading logconfig file from " + propertiesPath);
+        logger.fine("Getting and reading log config 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/Participant.java

@@ -2,9 +2,38 @@ package ch.zhaw.projekt2.turnierverwaltung;
 
 import java.io.Serializable;
 
+/**
+ * Interface that defines the common functionality of a Participant, used by Players and Teams
+ */
 public interface Participant extends Serializable {
+    /**
+     * Method that will be used to get
+     *
+     * @return the name
+     */
     String getName();
-    void setName(String name);
+
+    /**
+     * Method to set a participants name
+     *
+     * @param name to be set
+     * @throws InvalidNameException if the name does not follow the correct format
+     */
+    void setName(String name) throws InvalidNameException;
+
+    /**
+     * Method to compare two participants with each other
+     *
+     * @param participant to be compared to the current instance
+     * @return true if equal, false if not
+     */
     boolean equals(Participant participant);
-    void change(Participant participant);
+
+    /**
+     * Method to  change out participants
+     *
+     * @param participant to be exchanged
+     * @throws Person.InvalidPhoneNumberException if phone number does not follow the correct formatting
+     */
+    void change(Participant participant) throws Person.InvalidPhoneNumberException;
 }

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

@@ -1,56 +1,113 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
 import java.io.Serializable;
+import java.util.logging.Logger;
 
+/**
+ * Class that represents a person and holds its attributes
+ */
 public class Person implements Serializable {
     private final String NAME_MATCHING_REGEX = "[a-zA-Z]{1,20}";
-    private final String PHONE_MATCHING_REGEX = "[\\+]?[0-9]*";
+    private final String PHONE_MATCHING_REGEX = "[+]?[0-9]*";
 
     private String name;
     private String firstName;
     private String phoneNumber;
 
+    private static final Logger logger = Logger.getLogger(Person.class.getCanonicalName());
+
+
+    /**
+     * Constructor to initialize a person, also in charge of checking if name and phone number follow a valid format
+     *
+     * @param firstName   of the new person
+     * @param name        of the new person
+     * @param phoneNumber of the new person
+     * @throws InvalidNameException        thrown when the name or firstname does not follow the valid format
+     * @throws InvalidPhoneNumberException thrown when the number does not follow a valid format
+     */
     public Person(String firstName, String name, String phoneNumber) throws InvalidNameException, InvalidPhoneNumberException {
-        if(!firstName.matches(NAME_MATCHING_REGEX)){
-            throw new InvalidNameException("The First name is Invalid.");
-        } else if(!name.matches(NAME_MATCHING_REGEX)){
-            throw new InvalidNameException("The Last name is Invalid");
-        } else if(!phoneNumber.matches(PHONE_MATCHING_REGEX)){
-            throw new InvalidPhoneNumberException("The entered Phone Number is invalid.");
-        }
+        logger.finer("Trying to initialize a new person with name: " + name + ", first name: "
+                + firstName + ", Phone number: " + phoneNumber);
+
         setFirstName(firstName);
         setName(name);
         setPhoneNumber(phoneNumber);
+        logger.fine("Successfully created a new Person with Name: " + name + ", Firstname: "
+                + firstName + ", Phone number: " + phoneNumber);
     }
 
+    /**
+     * Method to return the name of a Person
+     *
+     * @return the name as String
+     */
     public String getName() {
+        logger.fine("Returning name of:" + name);
         return name;
     }
 
-    public void setName(String name) {
+    /**
+     * Method to set the name of a Person
+     *
+     * @param name of the person to be set
+     */
+    public void setName(String name) throws InvalidNameException {
+        if (!name.matches(NAME_MATCHING_REGEX)) {
+            logger.warning("Name: " + name + ", is not in a valid format");
+            throw new InvalidNameException("The Last name is Invalid");
+        }
+        logger.fine("Setting new name of " + this + " with: " + name);
         this.name = name;
     }
 
     public String getFirstName() {
+        logger.fine("Returning firstname of " + this + "that is: " + firstName);
         return firstName;
     }
 
-    public void setFirstName(String firstName) {
+    /**
+     * Method to set the first name of a Person
+     *
+     * @param firstName the person to be set
+     */
+    public void setFirstName(String firstName) throws InvalidNameException {
+        if (!firstName.matches(NAME_MATCHING_REGEX)) {
+            logger.warning("First name: " + firstName + ", is not in a valid format");
+            throw new InvalidNameException("The First name is Invalid.");
+        }
+        logger.fine("Setting new first name of " + this + " with: " + firstName);
         this.firstName = firstName;
     }
 
+    /**
+     * Method used to get the Phone number of a Person
+     *
+     * @return phone number of the person
+     */
     public String getPhoneNumber() {
+        logger.fine("returning phone number of " + this + "that is: " + phoneNumber);
         return phoneNumber;
     }
 
-    public void setPhoneNumber(String phoneNumber) {
+    /**
+     * Method used to set the Phone number of a Person
+     *
+     * @param phoneNumber to be set
+     */
+    public void setPhoneNumber(String phoneNumber) throws InvalidPhoneNumberException {
+        if (!phoneNumber.matches(PHONE_MATCHING_REGEX)) {
+            logger.warning("Phone number: " + phoneNumber + ", is not in a valid format");
+            throw new InvalidPhoneNumberException("The entered Phone Number is invalid.");
+        }
+        logger.fine("Setting new phone number of " + this + " with: " + phoneNumber);
         this.phoneNumber = phoneNumber;
     }
 
-    public class InvalidPhoneNumberException extends Exception {
-        public InvalidPhoneNumberException() {
-            super();
-        }
+    /**
+     * Exception, that is used when a Phone number is in an invalid format.
+     */
+    public static class InvalidPhoneNumberException extends Exception {
 
         public InvalidPhoneNumberException(String errorMessage) {
             super(errorMessage);
@@ -58,8 +115,13 @@ public class Person implements Serializable {
 
     }
 
+    /**
+     * Overridden toString method to be Return the name in Format "Firstname Name".
+     *
+     * @return Returning the Name in format "Firstname Name" as String
+     */
     @Override
-    public String toString(){
+    public String toString() {
         return firstName + " " + name;
     }
 

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

@@ -1,36 +1,78 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
 import java.io.Serializable;
+import java.util.logging.Logger;
 
+/**
+ * Class Representing a place that can be set for a game
+ */
 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(Place.class.getCanonicalName());
+
+    /**
+     * Constructor of a place initializes it and checks if name is in valid format
+     *
+     * @param name to be set
+     * @throws InvalidNameException If name is invalid
+     */
     public Place(String name) throws InvalidNameException {
-        if(!name.matches(NAME_MATCHING_REGEX)){
-            throw new InvalidNameException("The Name is Invalid.");
+        if (!name.matches(NAME_MATCHING_REGEX)) {
+            logger.warning("Name: " + name + " does not follow the valid format");
+            throw new InvalidNameException("The Name: " + name + " is in an invalid Format");
         }
+        logger.fine("Name: " + name + " is valid and will be set for the Place");
         setName(name);
     }
 
+    /**
+     * Method to get the Name of the Place as String
+     *
+     * @return name of place as String
+     */
     public String getName() {
+        logger.finer("returning the name: " + name);
         return name;
     }
 
-    public void setName(String name) {
+    /**
+     * Method to set the name of a place
+     *
+     * @param name the name to be set
+     */
+    private void setName(String name) {
+        logger.finer("Setting " + name + " as name of place");
         this.name = name;
     }
 
+    /**
+     * Override of toString to return the name as String when needed
+     *
+     * @return the name of the place as String
+     */
     @Override
-    public String toString(){
+    public String toString() {
         return name;
     }
 
-    public boolean equals(Place place){
+    /**
+     * Override of equals tom compare places with each other
+     *
+     * @param place to be compared with this instance
+     * @return true if equals and false if not equal
+     */
+    public boolean equals(Place place) {
+        logger.fine("Comparing " + place + " with " + this);
         return name.equals(place.getName());
     }
 
+    /**
+     *  Functionality to save more details than the name about a place is not implemented in this prototype,
+     *  so no functionality is set yet to change the place.
+     * @param place to be changed
+     */
     public void change(Place place) {
-        //TODO: If Place gets more developed in future releases
     }
 }

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

@@ -1,69 +1,127 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
+
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
+import java.util.logging.Logger;
 
-public class Player extends Person implements Participant{
+/**
+ * Class Representing a single Player
+ */
+public class Player extends Person implements Participant {
 
     private LocalDate dateOfBirth;
 
+    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.
+     * and checking if the format is valid
+     *
+     * @param firstName   the firstname of the player
+     * @param name        the name of the player
+     * @param phoneNumber the phone number of the player
+     * @param dateOfBirth the birthdate of the player
+     * @throws InvalidNameException        thrown when the name or firstname are not in a valid format
+     * @throws InvalidPhoneNumberException thrown when the phone number is not in a valid format
+     */
     public Player(String firstName, String name, String phoneNumber, String dateOfBirth) throws InvalidNameException, InvalidPhoneNumberException, InvalidDateException {
+
         super(firstName, name, phoneNumber);
+        logger.fine("initialized super of Player with firstname, name and phone number");
+        logger.finer("Setting the date of birth as:" + dateOfBirth);
         setDateOfBirth(dateOfBirth);
+        logger.finer("finished initializing the Player:" + name);
     }
 
+    /**
+     * Method to get the birthday of a player
+     *
+     * @return the birthday of a player
+     */
     public LocalDate getDateOfBirth() {
+        logger.fine("returning the birthday of " + getName());
         return dateOfBirth;
     }
 
-    public String getFormatedDateOfBirth(){
-        try{
+    /**
+     * Method that returns the date of birth formatted in eu way dd.MM.YYYY and as String
+     *
+     * @return String of formatted date
+     */
+    public String getFormattedDateOfBirth() {
+        logger.finer("Trying to get the formatted date");
+        try {
             DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy");
+            logger.fine("Returning the formatted birthdate of player: " + getName());
             return dateOfBirth.format(formatter);
         } catch (Exception e) {
-           //todo handle and logging
+            logger.warning("Failed to get formatted date for player " + getName() + "Error: " + e);
+            //TODO handle
             return "";
         }
     }
 
+
+    /**
+     * Method to set the date of Birth with a String provided.
+     *
+     * @param dateOfBirth to be as a String
+     */
     public void setDateOfBirth(String dateOfBirth) throws InvalidDateException {
-        if(dateOfBirth.length() > 0) {
+        logger.finer("Trying to set of birth with the String " + dateOfBirth + " provided");
+        if (dateOfBirth.length() > 0) {
             String[] date = dateOfBirth.split("\\.");
-            try{
-                this.dateOfBirth = LocalDate.of(Integer.valueOf(date[2]), Integer.valueOf(date[1]), Integer.valueOf(date[0]));
+            try {
+                this.dateOfBirth = LocalDate.of(Integer.parseInt(date[2]), Integer.parseInt(date[1]), Integer.parseInt(date[0]));
+                logger.fine("Date of birth of" + getName() + " has been set to " + dateOfBirth);
             } catch (NumberFormatException | IndexOutOfBoundsException e) {
                 e.printStackTrace();
+                logger.warning("Date of birth of " + getName() + " could not be set, leaving at null");
                 throw new InvalidDateException("Date invalid");
             }
-
         } else {
-            dateOfBirth = null;
+            logger.warning("Date of birth of " + getName() + " could not be set, leaving at null");
         }
     }
 
+    /**
+     * Method that sets date of Birth with a LocalDate provided
+     *
+     * @param dateOfBirth parameter given as LocalDate
+     */
     public void setDateOfBirth(LocalDate dateOfBirth) {
+        logger.fine("Setting date of birth of" + getName() + "with provided LocalDate: " + dateOfBirth);
         this.dateOfBirth = dateOfBirth;
     }
 
+    /**
+     * Override of equals method to compare participants against each other
+     *
+     * @param participant to be compared with this instance
+     * @return true if equals, false if not
+     */
     @Override
     public boolean equals(Participant participant) {
-        return getClass().equals(participant.getClass()) && toString().toLowerCase().equals(participant.toString().toLowerCase());
+        logger.fine("Comparing " + participant + " with " + this);
+        return getClass().equals(participant.getClass()) && toString().equalsIgnoreCase(participant.toString());
     }
 
+    /**
+     * Override of the change method to change a Participant with a new one
+     *
+     * @param participant the new participant to be added
+     */
     @Override
-    public void change(Participant participant) {
+    public void change(Participant participant) throws InvalidPhoneNumberException {
+        logger.fine("changing the current Player " + this + "with " + participant.getName());
         Player player = (Player) participant;
+
         setDateOfBirth(player.getDateOfBirth());
         setPhoneNumber(player.getPhoneNumber());
     }
 
-    public class InvalidDateException extends Exception {
-        public InvalidDateException() {
-            super();
-        }
-
+    public static class InvalidDateException extends Exception {
         public InvalidDateException(String errorMessage) {
             super(errorMessage);
         }

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

@@ -2,59 +2,129 @@ package ch.zhaw.projekt2.turnierverwaltung;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.logging.Logger;
 
+
+/**
+ * Class Team represents a team that can be added to a tournament
+ * (in the prototype there is no functionality for the team)
+ */
 public class Team implements Participant {
     private String name;
     private List<Player> players;
     private Person contactPerson;
 
-    public Team(String name){
+    private static final Logger logger = Logger.getLogger(Team.class.getCanonicalName());
+
+    /**
+     * Constructor to initiate a team, sets its name
+     *
+     * @param name the new name to be set
+     */
+    public Team(String name) {
+        logger.fine("Setting the new  name of the team as: " + name);
         setName(name);
         players = new ArrayList<>();
     }
 
-    public void addPlayer(Player player){
+    /**
+     * Method to add a new player to a team
+     *
+     * @param player new player to be added to a team
+     */
+    public void addPlayer(Player player) {
+        logger.fine("Adding new Player named: " + player + "into the team");
         players.add(player);
     }
 
+    /**
+     * Method to return the name of the team
+     *
+     * @return the name of the team
+     */
     @Override
     public String getName() {
+        logger.fine("Returning the name of the team:" + name);
         return name;
     }
 
+    /**
+     * Method to set the name of a team
+     *
+     * @param name of the team
+     */
     @Override
     public void setName(String name) {
         this.name = name;
     }
 
+    /**
+     * Method that sets a complete List of all players as players of the team
+     *
+     * @param players List of Players to be set
+     */
     public void setPlayers(List<Player> players) {
+        logger.fine("Inserts Player");
         this.players = players;
     }
 
+    /**
+     * Method to get the List of all Players in a team
+     *
+     * @return List of all players in team
+     */
     public List<Player> getPlayers() {
+        logger.fine("Returning List of all players in " + getName());
         return players;
     }
 
+    /**
+     * Override of equals Method to compare teams with each other
+     *
+     * @param participant to be compared with this instance
+     * @return true if teams are the same false if not.
+     */
     @Override
     public boolean equals(Participant participant) {
-        return getClass().equals(participant.getClass()) && toString().toLowerCase().equals(participant.toString().toLowerCase());
+        return getClass().equals(participant.getClass()) && toString().equalsIgnoreCase(participant.toString());
     }
 
+    /**
+     * Functionality to save a team is not implemented in this prototype, so no functionality is set yet to change the team
+     *
+     * @param participant date object containing new data
+     */
     @Override
     public void change(Participant participant) {
-        return;
     }
 
+    /**
+     * Method to get the current contact person of a team
+     *
+     * @return the current contact person
+     */
     public Person getContactPerson() {
+        logger.fine("Returning contact Person of team " + getName());
         return contactPerson;
     }
 
+    /**
+     * Method to set a Person as a contact person of a team
+     *
+     * @param contactPerson to be set
+     */
     public void setContactPerson(Person contactPerson) {
+        logger.fine("Setting " + contactPerson + " as a contact Person for team " + getName());
         this.contactPerson = contactPerson;
     }
 
+    /**
+     * Override of toString method, that returns the current name
+     *
+     * @return name in form of a String
+     */
     @Override
-    public String toString(){
+    public String toString() {
         return 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());
 
 
     /**
@@ -59,7 +59,7 @@ public class Tournament implements Serializable {
      *
      * @param newParticipant the Participant to be saved or edited
      */
-    public void saveParticipant(Participant newParticipant) {
+    public void saveParticipant(Participant newParticipant) throws Person.InvalidPhoneNumberException {
         logger.fine("Trying to add " + newParticipant + " into the tournament");
         for (Participant participant : participants) {
             if (participant.equals(newParticipant)) {
@@ -76,8 +76,8 @@ public class Tournament implements Serializable {
     /**
      * Method to remove an existing participant throws error if participant could not be found
      *
-     * @param participant
-     * @throws ParticipantNotExistsException
+     * @param participant to be removed
+     * @throws ParticipantNotExistsException thrown when the participant could not be found
      */
     public void removeParticipant(Participant participant) throws ParticipantNotExistsException {
         logger.finer("Trying to remove " + participant + " from participants List");
@@ -120,8 +120,9 @@ public class Tournament implements Serializable {
     }
 
     /**
-     * @param place
-     * @throws PlaceNotExistsException
+     * Method that removes a place from the List, also checks if place is in the list
+     * @param place to be removed
+     * @throws PlaceNotExistsException thrown when the place could not be found
      */
     public void removePlace(Place place) throws PlaceNotExistsException {
         if (!places.contains(place)) {
@@ -156,8 +157,6 @@ public class Tournament implements Serializable {
                 logger.warning("Invalid number of participants only participants 2^n allowed");
                 throw new NumberOfParticipantInvalidException("Can not Create Game Schedule for KO Modus");
             }
-
-
         } else {
             logger.warning("In the prototype the only accessible game schedule is the ko modus");
         }
@@ -209,7 +208,7 @@ public class Tournament implements Serializable {
     }
 
     /**
-     * Settermethod for the name of the tournament
+     * Setter method for the name of the tournament
      *
      * @param name the new name that should be set
      */
@@ -218,7 +217,7 @@ public class Tournament implements Serializable {
     }
 
     /**
-     * Gettermethod to get the type of the tournament
+     * Getter method to get the type of the tournament
      *
      * @return the type of the tournament
      */
@@ -230,7 +229,7 @@ public class Tournament implements Serializable {
     /**
      * Setter Method to set the type of the tournament
      *
-     * @param type
+     * @param type the type to be set
      */
     public void setType(Type type) {
         logger.fine("Setting the type of the tournament to: " + type);
@@ -238,7 +237,7 @@ public class Tournament implements Serializable {
     }
 
     /**
-     * Gettermethod to get the Complete GameList
+     * Getter method to get the Complete GameList
      *
      * @return the complete GameList
      */
@@ -254,17 +253,26 @@ public class Tournament implements Serializable {
     public enum Type {
         KO("KO-System"); //GROUPS("Gruppenspiele"); //Type GROUPS is not implemented in this prototype.
 
-        private String name;
+        private final String name;
 
-        private Type(String name) {
+        Type(String name) {
             this.name = name;
         }
 
+        /**
+         * Overridden toString method to return the name
+         * @return the name of the type
+         */
         @Override
         public String toString() {
             return name;
         }
 
+        /**
+         * Method to return an Observable List containing all types
+         *
+         * @return the Observable list with all types
+         */
         public static ObservableList<Type> getObservableList() {
             ObservableList<Type> items = FXCollections.observableArrayList();
             items.addAll(values());
@@ -275,11 +283,7 @@ public class Tournament implements Serializable {
     /**
      * Custom exception thrown when an invalid file is chosen
      */
-    public class InvalidTypeException extends Exception {
-        public InvalidTypeException() {
-            super();
-        }
-
+    public static class InvalidTypeException extends Exception {
         public InvalidTypeException(String errorMessage) {
             super(errorMessage);
         }
@@ -287,13 +291,9 @@ public class Tournament implements Serializable {
     }
 
     /**
-     * Custom Expeption thrown when a Participant does not exist
+     * Custom Exception thrown when a Participant does not exist
      */
-    public class ParticipantNotExistsException extends Exception {
-        public ParticipantNotExistsException() {
-            super();
-        }
-
+    public static class ParticipantNotExistsException extends Exception {
         public ParticipantNotExistsException(String errorMessage) {
             super(errorMessage);
         }
@@ -303,11 +303,7 @@ public class Tournament implements Serializable {
     /**
      * Custom Exception thrown when a Place does not exist
      */
-    public class PlaceNotExistsException extends Exception {
-        public PlaceNotExistsException() {
-            super();
-        }
-
+    public static class PlaceNotExistsException extends Exception {
         public PlaceNotExistsException(String errorMessage) {
             super(errorMessage);
         }
@@ -317,11 +313,7 @@ public class Tournament implements Serializable {
     /**
      * Custom Exception thrown when the number of participants is not valid
      */
-    public class NumberOfParticipantInvalidException extends Exception {
-        public NumberOfParticipantInvalidException() {
-            super();
-        }
-
+    public static class NumberOfParticipantInvalidException extends Exception {
         public NumberOfParticipantInvalidException(String msg) {
             super(msg);
         }

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

@@ -9,6 +9,8 @@ import java.util.List;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
+import java.util.logging.Logger;
+
 
 public class TournamentDecorator implements IsObservable{
     private Tournament tournament;
@@ -17,84 +19,134 @@ public class TournamentDecorator implements IsObservable{
     private ExecutorService executorService;
     private FactoryDecorator factoryDecorator;
 
+    private static final Logger logger = Logger.getLogger(TournamentDecorator.class.getCanonicalName());
+
+    /**
+     * Constructor to initialize TournamentDecorator
+     * adds a listener to save the tournament every time if something is changed.
+     * creates a executer service to do the saving process in separate thread for better performance.
+     * @param fileIO
+     */
     public TournamentDecorator(FileIO fileIO){
+        logger.fine("initializing TournamentDecorator");
         setFileIO(fileIO);
         addListener(new IsObserver() {
             @Override
             public void update() {
                 if(tournament != null){
-
                     saveTournament();
+                    logger.fine("listener to save tournament was added");
                 }
             }
         });
         executorService = Executors.newFixedThreadPool(1);
     }
 
+    /**
+     * Setter method of FactoryDecorator
+     * @param factoryDecorator the factory decorator to load different views.
+     */
     public void setFactoryDecorator(FactoryDecorator factoryDecorator) {
         this.factoryDecorator = factoryDecorator;
     }
 
+    /**
+     * Setter Method of FileIO
+     * @param fileIO the fileIO object to read and save to files.
+     */
     public void setFileIO(FileIO fileIO) {
         this.fileIO = fileIO;
     }
 
+    /**
+     * setter Method of Tournament
+     * @param tournament the new Tournament Object which was selected by user.
+     */
     public void setTournament(Tournament tournament) {
         this.tournament = tournament;
     }
 
+    /**
+     * getter Method of Tournament
+     * @return the actual tournament which is open.
+     */
     public Tournament getTournament() {
         return tournament;
     }
 
+    /**
+     * Method to add a listener in list.
+     * @param observer the observer object which should be informed.
+     */
     @Override
     public void addListener(IsObserver observer) {
         listener.add(observer);
     }
 
+    /**
+     * Method to remove a listener from list.
+     * @param observer the object to remove.
+     */
     @Override
     public void removeListener(IsObserver observer) {
         listener.remove(observer);
     }
 
-
+    /**
+     * Method to save the actual tournament to files.
+     */
     public void saveTournament(){
+        logger.fine("Saving Tournament to File.");
         executorService.execute(new saveTask());
         factoryDecorator.clearMessage(false);
-        factoryDecorator.printMessageToFooter("Zuletzt gespeichert: " + new Date().toString(),false);
+        String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("save");
+        factoryDecorator.printMessageToFooter(msg + new Date().toString(),false);
     }
 
 
-
+    /**
+     * Method to create a new Tournament. It checks if the name is valid, creates a new instance of Tournament and calls
+     * FileIO to save the new Tournament.
+     * @param name The name which was entered by the user.
+     * @param type The type of Tournament
+     */
     public void createTournament(String name, Tournament.Type type){
-
         try {
             if(fileIO.tournamentExists(name)){
-                //TODO:Logger
-                factoryDecorator.printMessageToFooter("Turniername existiert bereits",true);
+                logger.warning("a tournament with name " + name + "exists already.");
+                String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("tournamentExists");
+                factoryDecorator.printMessageToFooter(msg, true);
                 return;
             }
             Tournament tournament = new Tournament(name, type);
+            logger.fine("new tournament instance was created.");
             fileIO.saveTournament(tournament);
+            logger.fine("new Tournament File is saved.");
             factoryDecorator.clearMessage(true);
             informListener();
         } catch (InvalidNameException e) {
             e.printStackTrace();
-            //TODO: Logger
-            factoryDecorator.printMessageToFooter("Invalider Turniername",true);
+            logger.warning("The name which was entered is invalid.");
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidName");
+            factoryDecorator.printMessageToFooter(msg, true);
         } catch (Tournament.InvalidTypeException e) {
             e.printStackTrace();
-            //TODO: Logger
-            factoryDecorator.printMessageToFooter("Turniermodus nicht möglich",true);
-
+            logger.warning("The selected type of tournament is not valid.");
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidMode");
+            factoryDecorator.printMessageToFooter(msg, true);
         } catch (IOException e) {
             e.printStackTrace();
-            //TODO: Logger
-            factoryDecorator.printMessageToFooter("Fehler bei Dateizugriff",true);
+            logger.warning("Creating a new Tournament File was failed.");
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("IOException");
+            factoryDecorator.printMessageToFooter(msg, true);
         }
 
     }
 
+    /**
+     * Method to delete a Tournament File
+     * @param tournamentFile The File which should be deleted.
+     */
     public void deleteTournament(FileIO.TournamentFile tournamentFile){
         try {
             fileIO.deleteTournament(tournamentFile);
@@ -102,18 +154,24 @@ public class TournamentDecorator implements IsObservable{
             informListener();
         } catch (IOException e) {
             e.printStackTrace();  //TODO handle and logging
-            factoryDecorator.printMessageToFooter("Fehler bei Dateizugriff",true);
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("IOException");
+            factoryDecorator.printMessageToFooter(msg, true);
         }
     }
 
+    /**
+     * Method to create the list of games. The participants are entered in random order.
+     */
     public void createNewGameSchedule() {
-        //TODO: logging
+        logger.fine("Creating new Game Schedule");
         try {
             tournament.createGameSchedule();
             factoryDecorator.clearMessage(true);
         } catch (Tournament.NumberOfParticipantInvalidException e) {
             e.printStackTrace();
-            factoryDecorator.printMessageToFooter("Anzahl Teilnehmer nicht vielfaches von 2",true);
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("numberParticipant");
+            factoryDecorator.printMessageToFooter(msg, true);
+            logger.warning("Failed to create Game Schedule. The number of Participants is invalid.");
         }
         informListener();
     }
@@ -125,13 +183,16 @@ public class TournamentDecorator implements IsObservable{
             informListener();
         } catch (InvalidNameException e) {
             e.printStackTrace(); //TODO handle and logging
-            factoryDecorator.printMessageToFooter("Invalider Teilnehmername",true);
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidName");
+            factoryDecorator.printMessageToFooter(msg, true);
         } catch (Person.InvalidPhoneNumberException e) {
             e.printStackTrace(); //TODO handle and logging
-            factoryDecorator.printMessageToFooter("Invalide Telefonnummer",true);
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidPhone");
+            factoryDecorator.printMessageToFooter(msg, true);
         } catch (Player.InvalidDateException e) {
             e.printStackTrace();
-            factoryDecorator.printMessageToFooter("Ungültiges Geburtsdatum", true);
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidDate");
+            factoryDecorator.printMessageToFooter(msg, true);
         }
     }
 
@@ -142,8 +203,8 @@ public class TournamentDecorator implements IsObservable{
             informListener();
         } catch (Tournament.ParticipantNotExistsException e) {
             e.printStackTrace(); //TODO handle and logging
-            factoryDecorator.printMessageToFooter("Teilnehmer existiert nicht",true);
-
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("participantNotExist");
+            factoryDecorator.printMessageToFooter(msg, true);
         }
     }
 
@@ -154,7 +215,8 @@ public class TournamentDecorator implements IsObservable{
             informListener();
         } catch (InvalidNameException e) {
             e.printStackTrace(); //TODO handle and logging
-            factoryDecorator.printMessageToFooter("Invalider Ortsname",true);
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidName");
+            factoryDecorator.printMessageToFooter(msg, true);
         }
     }
 
@@ -165,7 +227,8 @@ public class TournamentDecorator implements IsObservable{
             informListener();
         } catch (Tournament.PlaceNotExistsException e) {
             e.printStackTrace(); //TODO handle and logging
-            factoryDecorator.printMessageToFooter("Ort existiert nicht",true);
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("placeNotExist");
+            factoryDecorator.printMessageToFooter(msg, true);
         }
     }
 
@@ -181,6 +244,7 @@ public class TournamentDecorator implements IsObservable{
         executorService.awaitTermination(2000, TimeUnit.MILLISECONDS);
     }
 
+
     private class saveTask implements Runnable {
 
         @Override
@@ -190,7 +254,8 @@ public class TournamentDecorator implements IsObservable{
             } catch (IOException e) {
                 e.printStackTrace();
                 Platform.runLater(() -> {
-                    factoryDecorator.printMessageToFooter("Datenzugriff nicht moeglich",true);
+                    String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("IOException");
+                    factoryDecorator.printMessageToFooter(msg, true);
                 });
             }
         }

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

@@ -1,34 +1,42 @@
 package ch.zhaw.projekt2.turnierverwaltung.main;
 
-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 ch.zhaw.projekt2.turnierverwaltung.*;
 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 Factory factory = new Factory(fileIO, tournamentDecorator);
+    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 {
+    public void start(Stage primaryStage) {
+        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);
         tournamentDecorator.setFactoryDecorator(factoryDecorator);
         factoryDecorator.openTournamentList();
+        languageConfigurator.translateGUI();
 
         Scene scene = new Scene(pane);
         primaryStage.setScene(scene);
@@ -40,6 +48,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

@@ -1,24 +1,70 @@
 package ch.zhaw.projekt2.turnierverwaltung.main;
 
 import ch.zhaw.projekt2.turnierverwaltung.FXController;
+import ch.zhaw.projekt2.turnierverwaltung.LanguageConfigurator;
 import javafx.application.Platform;
-import javafx.event.ActionEvent;
 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
-    void changeLangToGerman(ActionEvent event) {
 
+    private static final Logger logger = Logger.getLogger(MainWindowController.class.getCanonicalName());
+      
+    @FXML
+    private MenuItem closeBtn;
+
+    @FXML
+    private Label mainTitle;
+
+    @FXML
+    private Menu menuItemLanguage;
+
+     /**
+     * Method changes the language Setting to german
+     */
+    @FXML
+    void changeLangToGerman() {
+        getLanguageConfigurator().changeLanguage(LanguageConfigurator.Language.GERMAN);
     }
 
     @FXML
-    void closeApplication(ActionEvent event) {
+    void changeLangToEnglish() {
+        getLanguageConfigurator().changeLanguage(LanguageConfigurator.Language.ENGLISH);
+    }
+
+    /**
+     * This Method initializes the
+     */
+    @FXML
+    void closeApplication() {
+        logger.fine("");
         Platform.exit();
     }
 
+    /**
+     * There is no content to load
+     */
+    @Override
+    public void shareGUIElementWithLanguageConfigurator() {
+        getLanguageConfigurator().recieveLabel(mainTitle);
+        getLanguageConfigurator().recieveMenuItem(closeBtn);
+        getLanguageConfigurator().recieveMenuItem(menuItemLanguage);
+    }
+
+
+
     @Override
     public void loadContent() {
-
     }
 }

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

@@ -0,0 +1,52 @@
+package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
+
+
+import ch.zhaw.projekt2.turnierverwaltung.FileIO;
+import ch.zhaw.projekt2.turnierverwaltung.LanguageConfigurator;
+import javafx.scene.control.Alert;
+import javafx.scene.control.ButtonBar;
+import javafx.scene.control.ButtonType;
+
+import java.util.logging.Logger;
+
+
+/**
+ * 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;
+    private ButtonType noButton;
+    private Boolean result;
+    private String yes;
+    private String no;
+    private String titleDelete;
+    private String headerDelete;
+    private String contentDelete;
+
+    public AlertNewSchedule(LanguageConfigurator languageConfigurator){
+        super(Alert.AlertType.WARNING);
+        yes = languageConfigurator.getSelectedLanguage("yes");
+        no = languageConfigurator.getSelectedLanguage("no");
+        titleDelete = languageConfigurator.getSelectedLanguage("titleSchedule");
+        headerDelete = languageConfigurator.getSelectedLanguage("headerSchedule");
+        contentDelete = languageConfigurator.getSelectedLanguage("contentSchedule");
+        yesButton = new ButtonType(yes, ButtonBar.ButtonData.YES);
+        noButton = new ButtonType(no, ButtonBar.ButtonData.NO);
+        setTitle(titleDelete);
+        setHeaderText(headerDelete);
+        setContentText(contentDelete);
+        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;
+        });
+        return result;
+    }
+}

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;
@@ -32,6 +35,15 @@ public class GameController extends FXController{
     @FXML
     private TextField pointsTeamTwo;
 
+    @FXML
+
+    private Label locationLabel;
+
+    @Override
+    public void shareGUIElementWithLanguageConfigurator() {
+        getLanguageConfigurator().recieveLabel(locationLabel);
+    }
+
     @FXML
     void saveGameResult(Event event) {
         gameDecorator.saveGameResult(pointsTeamOne.getText(), pointsTeamTwo.getText());
@@ -42,12 +54,13 @@ public class GameController extends FXController{
         gameDecorator.saveGamePlace(newPlace);
     }
 
-    public double getGameBoxHeigth(){
+    public double getGameBoxHeight(){
         return mainVBox.getPrefHeight();
     }
 
     @Override
     public void loadContent() {
+        getLanguageConfigurator().translateGUI();
         participantNameOne.setText(gameDecorator.getParticipantOne());
         participantNameTwo.setText(gameDecorator.getParticipantTwo());
         pointsTeamOne.setText(String.valueOf(gameDecorator.getPoints1()));
@@ -71,9 +84,10 @@ public class GameController extends FXController{
     }
 
 
-    public void setup(TournamentDecorator tournamentDecorator, FileIO fileIO, FactoryDecorator factoryDecorator, Pane pane, GameDecorator gameDecorator) {
+    public void setup(TournamentDecorator tournamentDecorator, FileIO fileIO, FactoryDecorator factoryDecorator, Pane pane, GameDecorator gameDecorator,LanguageConfigurator languageConfigurator) {
         setTournamentDecorator(tournamentDecorator);
         this.gameDecorator = gameDecorator;
+        setup(languageConfigurator);
         placesChoiceBox.getSelectionModel().selectedItemProperty().addListener((ObservableValue<? extends Place> observable, Place oldValue, Place newValue) -> saveGamePlace(newValue == null ? oldValue : newValue));
     }
 

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

@@ -1,11 +1,11 @@
 package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
 
 import ch.zhaw.projekt2.turnierverwaltung.FXController;
-import ch.zhaw.projekt2.turnierverwaltung.Tournament;
 import javafx.event.ActionEvent;
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
 import javafx.scene.control.CheckBox;
+import javafx.scene.control.Labeled;
 import javafx.scene.layout.HBox;
 
 public class GameScheduleController extends FXController {
@@ -28,19 +28,35 @@ public class GameScheduleController extends FXController {
     @FXML
     private CheckBox treeView;
 
+    @Override
+    public void shareGUIElementWithLanguageConfigurator() {
+        getLanguageConfigurator().recieveLabel(treeView);
+        getLanguageConfigurator().recieveLabel(createScheduleBtn);
+        getLanguageConfigurator().recieveLabel(editParticipantBtn);
+        getLanguageConfigurator().recieveLabel(editLocBtn);
+        getLanguageConfigurator().recieveLabel(closeTournamentBtn);
+    }
+
     @FXML
     void createNewSchedule(ActionEvent event) {
-        getTournamentDecorator().createNewGameSchedule();
+        if (getTournamentDecorator().getTournament().getGameList().size() > 0) {
+            AlertNewSchedule alert = new AlertNewSchedule(getLanguageConfigurator());
+            if (alert.showAndGetResult()) {
+                getTournamentDecorator().createNewGameSchedule();
+            }
+        } else {
+            getTournamentDecorator().createNewGameSchedule();
+        }
     }
 
     @FXML
     void openPlacesFormular(ActionEvent event) {
-        getFactoryDecorator().openPlacesFormular();
+        getFactoryDecorator().openPlacesForm();
     }
 
     @FXML
     void openParticipantFormular(ActionEvent event) {
-        getFactoryDecorator().openParticipantFormular();
+        getFactoryDecorator().openParticipantForm();
     }
 
     @FXML

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/participantAddFormular/ParticipantFormularController.java

@@ -68,13 +68,26 @@ public class ParticipantFormularController extends FXController {
     @FXML
     private Button saveBtn;
 
+    @Override
+    public void shareGUIElementWithLanguageConfigurator() {
+        getLanguageConfigurator().recieveLabel(participantListTitle);
+        getLanguageConfigurator().recieveLabel(closeBtn);
+        getLanguageConfigurator().recieveLabel(deleteBtn);
+        getLanguageConfigurator().recieveLabel(newParticipantFormularTitle);
+        getLanguageConfigurator().recieveLabel(participantNameLabel);
+        getLanguageConfigurator().recieveLabel(firstNameLabel);
+        getLanguageConfigurator().recieveLabel(phoneNumberLabel);
+        getLanguageConfigurator().recieveLabel(birthDateLabel);
+        getLanguageConfigurator().recieveLabel(saveBtn);
+    }
+
     @FXML
     void changedSelection(MouseEvent event){
         Player participant = (Player) participantListView.getSelectionModel().getSelectedItems().get(0);
         participantNameTextField.setText(participant.getName());
         firstNameTextField.setText(participant.getFirstName());
         phoneNumberTextField.setText(participant.getPhoneNumber());
-        birthDateTextField.setText(participant.getFormatedDateOfBirth());
+        birthDateTextField.setText(participant.getFormattedDateOfBirth());
     }
 
     @FXML

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/placesAddFormular/PlacesFormularController.java

@@ -2,31 +2,24 @@ package ch.zhaw.projekt2.turnierverwaltung.main.placesAddFormular;
 
 import ch.zhaw.projekt2.turnierverwaltung.FXController;
 import ch.zhaw.projekt2.turnierverwaltung.Place;
-import ch.zhaw.projekt2.turnierverwaltung.Player;
 import ch.zhaw.projekt2.turnierverwaltung.Tournament;
-import javafx.event.ActionEvent;
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
 import javafx.scene.control.Label;
 import javafx.scene.control.ListView;
 import javafx.scene.control.TextField;
-import javafx.scene.input.MouseEvent;
 import javafx.scene.layout.GridPane;
 import javafx.scene.layout.VBox;
 
+import javafx.scene.input.MouseEvent;
+
+import java.util.logging.Logger;
+
+/**
+ * Controller of the places form, in charge of its functionality.
+ */
 public class PlacesFormularController extends FXController {
 
-    @FXML
-    private Button addBtn;
-
-    @FXML
-    private VBox changeBtn;
-
-    @FXML
-    private GridPane grid;
-
-    @FXML
-    private Label newPlaceFormularTitle;
 
     @FXML
     private Button closeBtn;
@@ -34,6 +27,8 @@ public class PlacesFormularController extends FXController {
     @FXML
     private Button deleteBtn;
 
+    @FXML
+    private Label newPlaceTitle;
 
     @FXML
     private Label placeListTitle;
@@ -50,37 +45,76 @@ public class PlacesFormularController extends FXController {
     @FXML
     private Button saveBtn;
 
+
+    private static final Logger logger = Logger.getLogger(PlacesFormularController.class.getCanonicalName());
+
+
+    @Override
+    public void shareGUIElementWithLanguageConfigurator() {
+        getLanguageConfigurator().recieveLabel(placeListTitle);
+        getLanguageConfigurator().recieveLabel(newPlaceTitle);
+        getLanguageConfigurator().recieveLabel(placeNameLabel);
+        getLanguageConfigurator().recieveLabel(closeBtn);
+        getLanguageConfigurator().recieveLabel(deleteBtn);
+        getLanguageConfigurator().recieveLabel(saveBtn);
+
+    }
+
+      /**
+     * Selects an item (place) from the List view
+     */
     @FXML
-    void changedSelection(MouseEvent event){
+    void changedSelection() {
         Place place = placeListView.getSelectionModel().getSelectedItems().get(0);
+        logger.finer("Selected new Place from list: " + place);
         placeNameTextField.setText(place.getName());
     }
 
+    /**
+     * Saves the name of a new place into the list and clears the form
+     */
     @FXML
-    void savePlace(ActionEvent event) {
+    void savePlace() {
         getTournamentDecorator().savePlace(placeNameTextField.getText());
-        clearFormular();
+        logger.fine("Saved " + placeNameTextField + " to the list of places");
+        clearForm();
     }
 
-    private void clearFormular() {
+    /**
+     * Method clears the input field
+     */
+    private void clearForm() {
+        logger.finer("Clearing input text field");
         placeNameTextField.clear();
     }
 
+    /**
+     * Method deletes the currently selected place from the list.
+     */
     @FXML
-    void delete(ActionEvent event) {
+    void delete() {
         Place place = placeListView.getSelectionModel().getSelectedItems().get(0);
+        logger.fine("Deleting " + place + "from place list");
         getTournamentDecorator().deletePlace(place);
     }
 
+    /**
+     * Closes the current Place view, going back to previous view
+     */
     @FXML
-    void close(ActionEvent event) {
+    void close() {
+        logger.fine("Closing place form");
         getFactoryDecorator().openScheduleView();
     }
 
+    /**
+     * Loads the already saved places and displays them on the places list.
+     */
     @Override
     public void loadContent() {
+        logger.fine("Getting the Saved tournaments into the Places list");
         Tournament tournament = getTournamentDecorator().getTournament();
-        if(tournament != null){
+        if (tournament != null) {
             placeListView.setItems(tournament.getPlaces());
         } else {
             placeListView.getItems().clear();

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/tournamentList/AlertDelete.java

@@ -1,29 +1,39 @@
 package ch.zhaw.projekt2.turnierverwaltung.main.tournamentList;
 
+import ch.zhaw.projekt2.turnierverwaltung.LanguageConfigurator;
 import javafx.scene.control.Alert;
 import javafx.scene.control.ButtonBar;
 import javafx.scene.control.ButtonType;
 
 public class AlertDelete extends Alert {
-    ButtonType yesButton = new ButtonType("Ja", ButtonBar.ButtonData.YES);
-    ButtonType noButton = new ButtonType("Nein", ButtonBar.ButtonData.NO);
+    ButtonType yesButton;
+    ButtonType noButton;
     Boolean result;
+    String yes;
+    String no;
+    String titleDelete;
+    String headerDelete;
+    String contentDelete;
 
-    public AlertDelete(String name){
+    public AlertDelete(LanguageConfigurator languageConfigurator){
         super(Alert.AlertType.WARNING);
-        setTitle("Entfernen");
-        setHeaderText("Turnier entfernen?");
-        setContentText("Sind Sie sicher, dass sie das Turnier " + name + " entfernen wollen?\n" +
-                "Nach diesem Vorgang kann es nicht wiederhergestellt werden.");
+        yes = languageConfigurator.getSelectedLanguage("yes");
+        no = languageConfigurator.getSelectedLanguage("no");
+        titleDelete = languageConfigurator.getSelectedLanguage("titleDelete");
+        headerDelete = languageConfigurator.getSelectedLanguage("headerDelete");
+        contentDelete = languageConfigurator.getSelectedLanguage("contentDelete");
+        yesButton = new ButtonType(yes, ButtonBar.ButtonData.YES);
+        noButton = new ButtonType(no, ButtonBar.ButtonData.NO);
+        setTitle(titleDelete);
+        setHeaderText(headerDelete);
+        setContentText(contentDelete);
         getButtonTypes().setAll(yesButton, noButton);
     }
 
     public boolean showAndGetResult() {
         result = false;
         showAndWait().ifPresent(type -> {
-            if (type == yesButton) {
-                result = true;
-            }
+            result = type == yesButton;
         });
         return result;
     }

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/tournamentList/TournamentListController.java

@@ -25,8 +25,6 @@ public class TournamentListController extends FXController {
     @FXML
     private Button createBtn;
 
-    @FXML
-    private GridPane grid;
 
     @FXML
     private ChoiceBox<Tournament.Type> modusChoiceBox;
@@ -55,6 +53,17 @@ public class TournamentListController extends FXController {
     @FXML
     private TextField tournamentNameField;
 
+    @Override
+    public void shareGUIElementWithLanguageConfigurator() {
+        getLanguageConfigurator().recieveLabel(createBtn);
+        getLanguageConfigurator().recieveLabel(newTournamentFormularTitle);
+        getLanguageConfigurator().recieveLabel(openBtn);
+        getLanguageConfigurator().recieveLabel(deleteBtn);
+        getLanguageConfigurator().recieveLabel(tournamentListTitle);
+        getLanguageConfigurator().recieveLabel(tournamentModLabel);
+        getLanguageConfigurator().recieveLabel(tournamentNameLabel);
+    }
+
     @FXML
     void createTournament(ActionEvent event) {
         getTournamentDecorator().createTournament(tournamentNameField.getText(), modusChoiceBox.getValue());
@@ -69,7 +78,7 @@ public class TournamentListController extends FXController {
     @FXML
     void deleteTournament(ActionEvent event) {
         FileIO.TournamentFile tournamentFile = tournamentListView.getSelectionModel().getSelectedItems().get(0);
-        AlertDelete alert = new AlertDelete(tournamentFile.toString());
+        AlertDelete alert = new AlertDelete(getLanguageConfigurator());
         if(alert.showAndGetResult()){
            getTournamentDecorator().deleteTournament(tournamentFile);
         }

app/src/main/resources/ch/zhaw/projekt2/turnierverwaltung/MainWindow.fxml

@@ -16,17 +16,18 @@
                <menus>
                   <Menu mnemonicParsing="false" text="Start">
                      <items>
-                        <Menu mnemonicParsing="false" text="Sprache">
+                        <Menu fx:id="menuItemLanguage" mnemonicParsing="false" text="Sprache">
                            <items>
                               <MenuItem mnemonicParsing="false" onAction="#changeLangToGerman" text="Deutsch" />
+                              <MenuItem mnemonicParsing="false" onAction="#changeLangToEnglish" text="English" />
                            </items>
                         </Menu>
-                        <MenuItem mnemonicParsing="false" onAction="#closeApplication" text="Close" />
+                        <MenuItem fx:id="closeBtn" mnemonicParsing="false" onAction="#closeApplication" text="Close" />
                      </items>
                   </Menu>
                </menus>
             </MenuBar>
-            <Label text="Turnier Manager">
+            <Label fx:id="mainTitle" text="Turnier Manager">
                <font>
                   <Font name="System Bold" size="40.0" />
                </font>

app/src/main/resources/ch/zhaw/projekt2/turnierverwaltung/gameScheduleView/Game.fxml

@@ -42,7 +42,7 @@
             </HBox>
             <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0">
                <children>
-                  <Label text="Ort">
+                  <Label fx:id="locationLabel" text="Ort">
                      <HBox.margin>
                         <Insets right="20.0" />
                      </HBox.margin>

app/src/main/resources/ch/zhaw/projekt2/turnierverwaltung/gameScheduleView/GameSchedule.fxml

@@ -18,7 +18,7 @@
    <top>
       <HBox alignment="CENTER_LEFT" prefHeight="100.0" prefWidth="200.0" BorderPane.alignment="CENTER">
          <children>
-            <CheckBox fx:id="treeView" mnemonicParsing="false" onAction="#changeView" selected="true" text="Baumansicht">
+            <CheckBox fx:id="treeView" minWidth="100.0" mnemonicParsing="false" onAction="#changeView" selected="true" text="Baumansicht" textOverrun="WORD_ELLIPSIS" wrapText="true">
                <HBox.margin>
                   <Insets left="20.0" right="20.0" />
                </HBox.margin>

app/src/main/resources/ch/zhaw/projekt2/turnierverwaltung/placesAddFormular/PlacesFormular.fxml

@@ -1,11 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<?import javafx.geometry.*?>
-<?import javafx.scene.control.*?>
-<?import javafx.scene.layout.*?>
-<?import javafx.scene.text.*?>
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.ListView?>
+<?import javafx.scene.control.Separator?>
+<?import javafx.scene.control.TextField?>
+<?import javafx.scene.layout.ColumnConstraints?>
+<?import javafx.scene.layout.GridPane?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.RowConstraints?>
+<?import javafx.scene.layout.VBox?>
+<?import javafx.scene.text.Font?>
 
-<HBox alignment="CENTER" VBox.vgrow="ALWAYS" xmlns="http://javafx.com/javafx/11.0.2" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.placesAddFormular.PlacesFormularController">
+<HBox alignment="CENTER" VBox.vgrow="ALWAYS" xmlns="http://javafx.com/javafx/18" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.placesAddFormular.PlacesFormularController">
    <children>
       <VBox alignment="TOP_CENTER" prefHeight="331.0" prefWidth="308.0" HBox.hgrow="ALWAYS">
          <children>
@@ -48,7 +56,7 @@
       </Separator>
       <VBox fx:id="changeBtn" alignment="TOP_CENTER" prefHeight="331.0" prefWidth="308.0" HBox.hgrow="ALWAYS">
          <children>
-            <Label fx:id="newplaceFormularTitle" text="Ort ändern/erstellen">
+            <Label fx:id="newPlaceTitle" text="Ort ändern/erstellen">
                <font>
                   <Font name="System Bold" size="21.0" />
                </font>

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));