Feedback Ruiz

Dear Angry Nerds Team. Here you are the feedback for your project. BTW: Very good your application offer English and German language!
Merge pull request #57 from PM2-IT21bWIN-ruiz-mach-krea/logging_and_docs
2022-05-26 20:05:07 +02:00 · 2022-05-13 23:57:50 +02:00 · 2022-05-13 23:57:41 +02:00 · 2022-05-13 23:57:31 +02:00 · 2022-05-13 23:56:37 +02:00 · 2022-05-13 23:56:26 +02:00
45 changed files with 1913 additions and 357 deletions
--- a/ClassDiagram.png
+++ b/ClassDiagram.png
--- a/Feedback_ruiz.pdf
+++ b/Feedback_ruiz.pdf
--- a/README.md
+++ b/README.md
@ -1 +1,70 @@
 # team02-AngryNerds-projekt2-turnierverwaltung
+
+## Tournament administration
+### Documentation
+
+> Our Tournament Administration Tool is available in german and english,
+> to change the language click on start in the top left corner and then select your 
+> desired language under 'Sprache' or 'Language' (documentation is only provided in english).
+
+Once you start the Programm you will be presented with the possibility to either create a new tournament or load one if one has already been saved.
+
+>To create a new tournament simply type in the name of it and press create
+
+>To load a tournament select the tournament on the list and click open
+
+>You can also delete a tournament by selecting it and then clicking delete
+
+Once a tournament has been created you will be sent to the tournament screen.
+Your next step should be adding a place or players you can do so vie Edit Participants or Edit Locations.
+
+Once you have enough Players(min 4 and only number that are 2^n e.g. 4, 8, 16...), you can click the Create game schedule button and the schedule will be created
+
+you can then input the location where a game takes place and as well the points a team scored
+the winning team will then automatically advance in the tree.
+
+The Programm automatically saves, so no worries you won't lose your progress.
+
+# Startup and Testing
+To Start the Programm use the command
+>./gradlew run
+
+To run the tests use the command
+>./gradlew test
+
+# Branching Model
+We used a simple branching model, for each new functionality or working step a new branch would be created, once a segment was finished the branch would then be reviewed by peers and be pushed into the main branch via a pull request, no direct work is usually done in the main branch. 
+
+# Class Diagramm
+Our class Diagramm can be found [here](https://github.zhaw.ch/PM2-IT21bWIN-ruiz-mach-krea/team02-AngryNerds-projekt2-turnierverwaltung/blob/main/ClassDiagram.png)
+# Architecture
+
+Our Model View Pattern has been set, so  that the class Tournament acts as the Model.
+Each View has its own unique controller assigned
+For Comprehensive Reasons all Controller Classes inherit from the abstract super class FX Controller.
+
+The Class Tournament decorator has the purpose of communication of the controller classes with the Model of the tournament, the same Decorator also communicates with the FileIO and inherits the task of saving or importing save files into the program.
+
+The Class Tournament Decorator always stores the Tournament that is opened in a data field.
+The Factory and its associated Factory Decorators are responsible to load all the views if application is started. And to switch between the views while using the application.
+
+The Factory decorator is placed between the controllers and the factory to enable the communication.
+
+The Model tournament saves a List of all participants, all places and all games. Participants are implemented as an interface, since we want to be able to save a team or a single player as participant (in the prototype it is not possible to create a team).
+
+To refresh the view of the tournament tree, each game has its own game decorator with a list of listeners.
+
+To realize the tree there are listeners placed in the game decorators of the previous round to gather the winner and calculate the new participants of a game. Listeners are only placed 
+
+Loggers are implemented in all relevant classes
+Each class creates its own logger a root logger is created in the LogConfiguration class and two Handlers are specified for use, one File Handler and one Console Handler.
+The setting of those handlers can be set in the file log.properties.
+
+We choose this architecture since it gives us the advantage to add more views without having any more code duplication.
+We also think it is an advantage that the saving automatically takes place and the user does not have to take into consideration to save from time to time.
+It also closely resembles what we learned already in lectures we had previously, so we were able to implement it accordingly.
+
+# Notable Pullrequests
+[Number 1](https://github.zhaw.ch/PM2-IT21bWIN-ruiz-mach-krea/team02-AngryNerds-projekt2-turnierverwaltung/pull/22)
+[Number 2](https://github.zhaw.ch/PM2-IT21bWIN-ruiz-mach-krea/team02-AngryNerds-projekt2-turnierverwaltung/pull/20)
+
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/App.java
+++ b/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);
        }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FXController.java
+++ b/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,30 +19,34 @@ 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);
    }

-    protected void removeListener(){
-        tournamentDecorator.removeListener(listener);
-        factoryDecorator.removeListener(listener);
-    }
-
    protected TournamentDecorator getTournamentDecorator() {
        return tournamentDecorator;
    }
@ -69,4 +74,8 @@ public abstract class FXController {
    protected Pane getPane() {
        return pane;
    }
+
+    protected LanguageConfigurator getLanguageConfigurator() {
+        return languageConfigurator;
+    }
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Factory.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Factory.java
@ -2,98 +2,156 @@ package ch.zhaw.projekt2.turnierverwaltung;

 import ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView.GameController;
 import ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView.GameDecorator;
-import ch.zhaw.projekt2.turnierverwaltung.main.tournamentList.TournamentListController;
 import javafx.fxml.FXMLLoader;
 import javafx.geometry.Insets;
 import javafx.scene.control.Label;
 import javafx.scene.layout.*;
 import javafx.scene.paint.Color;
 import javafx.scene.text.Font;
-
 import java.io.IOException;
-import java.net.URL;
-import java.nio.charset.Charset;
+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;
-    //TODO save views instead of recreate them.
+    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;
+        this.languageConfigurator = languageConfigurator;
    }

-    public TournamentDecorator getTournamentDecorator() {
-        return tournamentDecorator;
-    }
-
+    /**
+     * 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;
    }

-    public void loadTournamentList(BorderPane pane, FactoryDecorator factoryDecorator) {
+    /**
+     * 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();
+                logger.warning("failed to load views.");
+            }
+        }
+    }
+
+    /**
+     * Method to show the view TournamentList
+     * @param pane the Pane where the View will be visible
+     */
+    public void showTournamentList(BorderPane pane) {
        tournamentDecorator.setTournament(null);
-        TournamentListController controller = (TournamentListController) setCenterOfBorderPane(pane, getClass().getResource("tournamentList/tournamentList.fxml"), factoryDecorator);
+        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 loadParticipantFormular(BorderPane pane, FactoryDecorator factoryDecorator) {
-        setCenterOfBorderPane(pane, getClass().getResource("participantAddFormular/participantFormular.fxml"), 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 loadPlacesFormular(BorderPane pane, FactoryDecorator factoryDecorator) {
-        setCenterOfBorderPane(pane, getClass().getResource("placesAddFormular/PlacesFormular.fxml"), 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 loadGameScheduler(BorderPane pane, FactoryDecorator factoryDecorator) {
-        setCenterOfBorderPane(pane, getClass().getResource("gameScheduleView/GameSchedule.fxml"), 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;
    }

-    private FXController setCenterOfBorderPane(BorderPane pane, URL location, FactoryDecorator factoryDecorator) {
-        FXController controller = null;
-        try {
-            FXMLLoader loader = new FXMLLoader(location);
-            pane.setCenter(loader.load());
-            controller = loader.getController();
-            controller.setup(tournamentDecorator, fileIO, factoryDecorator, pane);
-            VBox bottom = (VBox) pane.getBottom();
-            resetFooter(pane, true);
-        } catch (IOException e) {
-            e.printStackTrace();
-            //TODO handle and logging?
-        }
-        return controller;
-    }
-
-
+    /**
+     * 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;
@ -116,11 +174,15 @@ public class Factory {
            innerVbox.getChildren().add(label);

        }
-
-
    }

+    /**
+     * 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) {
@ -132,4 +194,50 @@ 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"),
+        placesFormular("placesAddFormular/PlacesFormular.fxml"),
+        gameScheduler("gameScheduleView/GameSchedule.fxml");
+
+        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;
+        }
+
+        public Pane getPane() {
+            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, languageConfigurator);
+        }
+
+    }
+
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FactoryDecorator.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FactoryDecorator.java
@ -12,75 +12,156 @@ 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");
+            logger.warning("Failed to open tournament file Error: " + e);
+            printMessageToFooter(msg, true);
+        }
    }

+    /**
+     * Initializes the display of the Tournament list view
+     */
    public void openTournamentList() {
-        factory.loadTournamentList((BorderPane) pane, this);
+        logger.fine("Showing TournamentList view");
+        factory.showTournamentList((BorderPane) pane);
        informListener();
    }

-    public void openParticipantFormular() {
-        factory.loadParticipantFormular((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.loadPlacesFormular((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.loadGameScheduler((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) {
+            return;
+        }
+
        List<List<Game>> gameList = tournamentDecorator.getTournament().getGameList();

        List<GameDecorator> gameDecoratorsList = new ArrayList<>();
@ -89,7 +170,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 {
@ -99,12 +180,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
@ -115,28 +196,35 @@ public class FactoryDecorator implements IsObservable{
                gameController.loadContent();
            }
            hBoxCenter.getChildren().add(vBox);
-            if(treeView){
-                if(i+1 < gameList.size())
+            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);


@ -153,20 +241,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();
        }
    }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FileIO.java
+++ b/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);
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Game.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Game.java
@ -1,85 +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;
    }

-    public Place getLocation() {
-        return place;
-    }
-
-    public void setLocation(Place place) {
-        this.place = place;
-    }
-
+    /**
+     * 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);
    }

 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/InvalidNameException.java
+++ b/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);
    }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/IsObservable.java
+++ b/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);
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/IsObserver.java
+++ b/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
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/LanguageConfigurator.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/LanguageConfigurator.java
@ -0,0 +1,192 @@
+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
+    }
+}
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/LogConfiguration.java
+++ b/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");
    }
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Participant.java
+++ b/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;
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Person.java
+++ b/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;
    }

--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Place.java
+++ b/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
    }
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Player.java
+++ b/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);
        }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Team.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Team.java
@ -2,59 +2,128 @@ 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;
    }
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Tournament.java
+++ b/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
     */
@ -252,19 +251,28 @@ public class Tournament implements Serializable {
     * (In the Prototype only the KO-System has full functionality
     */
    public enum Type {
-        KO("KO-System"), GROUPS("Gruppenspiele");
+        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);
        }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/TournamentDecorator.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/TournamentDecorator.java
@ -1,13 +1,15 @@
 package ch.zhaw.projekt2.turnierverwaltung;

 import javafx.application.Platform;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Date;
 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;
@ -16,84 +18,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);
@ -101,18 +153,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();
    }
@ -124,13 +182,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);
        }
    }

@ -141,8 +202,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);
        }
    }

@ -153,7 +214,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);
        }
    }

@ -164,7 +226,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);
        }
    }

@ -175,6 +238,12 @@ public class TournamentDecorator implements IsObservable{
        }
    }

+    public void closeApplication() throws InterruptedException {
+        executorService.shutdown();
+        executorService.awaitTermination(2000, TimeUnit.MILLISECONDS);
+    }
+
+
    private class saveTask implements Runnable {

        @Override
@ -184,7 +253,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);
                });
            }
        }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindow.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindow.java
@ -1,38 +1,62 @@
 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.fxml.FXMLLoader;
 import javafx.scene.Scene;
 import javafx.scene.layout.BorderPane;
 import javafx.stage.Stage;

+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); //TODO make it private!
+    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);
+        primaryStage.setMinHeight(600);
+        primaryStage.setMinWidth(800);
        primaryStage.setMaximized(true);
        primaryStage.setResizable(true);
        primaryStage.setFullScreen(false);
        primaryStage.show();
    }

-
+    /**
+     * Method used to safely shut down the application
+     */
+    @Override
+    public void stop() {
+        try {
+            super.stop();
+            tournamentDecorator.closeApplication();
+        } catch (Exception e) {
+            logger.warning("Exception while closing application");
+        }
+    }
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindowController.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindowController.java
@ -1,23 +1,75 @@
 package ch.zhaw.projekt2.turnierverwaltung.main;

 import ch.zhaw.projekt2.turnierverwaltung.FXController;
-import javafx.event.ActionEvent;
+import ch.zhaw.projekt2.turnierverwaltung.LanguageConfigurator;
+import javafx.application.Platform;
 import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuItem;
+import java.util.logging.Logger;

+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);
+        logger.fine("language setting changed to german");
    }

    @FXML
-    void closeApplication(ActionEvent event) {
-
+    void changeLangToEnglish() {
+        getLanguageConfigurator().changeLanguage(LanguageConfigurator.Language.ENGLISH);
+        logger.fine("language setting changed to 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);
+    }
+
+
+    /**
+     * There is no content to load
+     */
    @Override
    public void loadContent() {
-
    }
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/AlertNewSchedule.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/AlertNewSchedule.java
@ -0,0 +1,58 @@
+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;
+/**
+ * Class that is used to display the popup window to confirm a sensitive action of the user.
+ */
+
+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;
+
+    /**
+     * Popup to ask the user if he is sure that he wants to reshuffle the game board.
+     */
+    public AlertNewSchedule(LanguageConfigurator languageConfigurator){
+        super(Alert.AlertType.WARNING);
+        yes = languageConfigurator.getSelectedLanguage("yes");
+        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;
+    }
+}
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameController.java
+++ b/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;
@ -33,7 +36,16 @@ public class GameController extends FXController{
    private TextField pointsTeamTwo;

    @FXML
-    void saveGameResult(Event event) {
+
+    private Label locationLabel;
+
+    @Override
+    public void shareGUIElementWithLanguageConfigurator() {
+        getLanguageConfigurator().recieveLabel(locationLabel);
+    }
+
+    @FXML
+    void saveGameResult() {
        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,10 +84,11 @@ 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;
-        placesChoiceBox.getSelectionModel().selectedItemProperty().addListener((ObservableValue<? extends Place> observable, Place oldValue, Place newValue) -> saveGamePlace(newValue));
+        setup(languageConfigurator);
+        placesChoiceBox.getSelectionModel().selectedItemProperty().addListener((ObservableValue<? extends Place> observable, Place oldValue, Place newValue) -> saveGamePlace(newValue == null ? oldValue : newValue));
    }

 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameDecorator.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameDecorator.java
@ -1,29 +1,51 @@
 package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;

 import ch.zhaw.projekt2.turnierverwaltung.*;
-
 import java.util.ArrayList;
 import java.util.List;

-
+/**
+ * This Class is used by the GameController for additional functionality and holds the listeners and the Model Game
+ */
 public class GameDecorator implements IsObservable{
    private Game game;
    private List<IsObserver> listener = new ArrayList<>();

+    /**
+     * Setup the GameDecorator
+     *
+     * @param game Model for the Controller
+     */
    public GameDecorator (Game game) {
        this.game = game;
    }

+    /**
+     * 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) {
        listener.add(observer);
    }

+    /**
+     * Removes a Listener from the Listener List
+     *
+     * @param observer the Listener to be removed
+     */
    @Override
    public void removeListener(IsObserver observer) {
        listener.remove(observer);
    }

+    /**
+     * Saves the Gameresult in the model
+     *
+     * @param points1 points achieved in textfield one
+     * @param points2 points achieved in textfield two
+     */
    public void saveGameResult(String points1, String points2){
        if(points1.length() > 0){
            game.setPoints1(Integer.parseInt(points1));
@ -38,19 +60,35 @@ public class GameDecorator implements IsObservable{
        informListener();
    }

+    /**
+     * Saves the Place in the Model
+     *
+     * @param place
+     */
    public void saveGamePlace(Place place){
        game.setPlace(place);
        informListener();
    }

+    /**
+     * @return game points from player one
+     */
    public String getPoints1() {
       return String.valueOf(game.getPoints1());
    }

+    /**
+     *
+     *@return game points from player two
+     */
    public String getPoints2() {
        return String.valueOf(game.getPoints2());
    }

+    /**
+     *
+     * @return returns Gameparticipant one
+     */
    public String getParticipantOne() {
        if (game.getParticipant1() != null) {
            return game.getParticipant1().toString();
@ -58,6 +96,10 @@ public class GameDecorator implements IsObservable{
        return "1";
    }

+    /**
+     *
+     * @return returns Gameparticipant two
+     */
    public String getParticipantTwo() {
        if (game.getParticipant2() != null) {
            return game.getParticipant2().toString();
@ -65,15 +107,25 @@ public class GameDecorator implements IsObservable{
        return "2";
    }

+    /**
+     * calls method in model to refresh participant
+     */
    public void refreshParticipants(){
        game.refreshParticipants();
        informListener();
    }

+    /**
+     *
+     * @return place
+     */
    public Place getPlace() {
        return game.getPlace();
    }

+    /**
+     * Method that informs all listeners of an update.
+     */
    public void informListener() {
        for(IsObserver observer : listener) {
            observer.update();
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameScheduleController.java
+++ b/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,26 +28,39 @@ 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) {
+        if (getTournamentDecorator().getTournament().getGameList().size() > 0) {
+            AlertNewSchedule alert = new AlertNewSchedule(getLanguageConfigurator());
+            if (alert.showAndGetResult()) {
                getTournamentDecorator().createNewGameSchedule();
            }
+        } else {
+            getTournamentDecorator().createNewGameSchedule();
+        }
+    }

    @FXML
    void openPlacesFormular(ActionEvent event) {
-        removeListener();
-        getFactoryDecorator().openPlacesFormular();
+        getFactoryDecorator().openPlacesForm();
    }

    @FXML
    void openParticipantFormular(ActionEvent event) {
-        removeListener();
-        getFactoryDecorator().openParticipantFormular();
+        getFactoryDecorator().openParticipantForm();
    }

    @FXML
    void closeTournament(ActionEvent event) {
-        removeListener();
        getFactoryDecorator().openTournamentList();
    }

--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/participantAddFormular/ParticipantFormularController.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/participantAddFormular/ParticipantFormularController.java
@ -3,6 +3,7 @@ package ch.zhaw.projekt2.turnierverwaltung.main.participantAddFormular;
 import ch.zhaw.projekt2.turnierverwaltung.FXController;
 import ch.zhaw.projekt2.turnierverwaltung.Participant;
 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;
@ -13,6 +14,11 @@ import javafx.scene.input.MouseEvent;
 import javafx.scene.layout.GridPane;
 import javafx.scene.layout.VBox;

+import java.util.logging.Logger;
+
+/**
+ * Controller of Participant
+ */
 public class ParticipantFormularController extends FXController {

    @FXML
@ -67,21 +73,49 @@ public class ParticipantFormularController extends FXController {
    @FXML
    private Button saveBtn;

+    private static final Logger logger = Logger.getLogger(ParticipantFormularController.class.getCanonicalName());
+
+    /**
+     * Shares GUI Elements with the LanguageConfigurator
+     */
+    @Override
+    public void shareGUIElementWithLanguageConfigurator() {
+        logger.fine("sharing GUI Elements");
+        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);
+    }
+
+    /**
+     * Changes the current selection
+     */
    @FXML
-    void changedSelection(MouseEvent event){
+    void changedSelection(){
        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());
    }

+    /**
+     * Saves a new Participant and clears form
+     */
    @FXML
-    void saveParticipant(ActionEvent event) {
+    void saveParticipant() {
        getTournamentDecorator().savePlayer(firstNameTextField.getText(), participantNameTextField.getText(), phoneNumberTextField.getText(), birthDateTextField.getText());
        clearFormular();
    }

+    /**
+     * Clears current form
+     */
    private void clearFormular() {
        firstNameTextField.clear();
        participantNameTextField.clear();
@ -89,20 +123,35 @@ public class ParticipantFormularController extends FXController {
        birthDateTextField.clear();
    }

+    /**
+     * Deletes the selected participant.
+     */
    @FXML
-    void delete(ActionEvent event) {
+    void delete() {
        Participant participant = participantListView.getSelectionModel().getSelectedItems().get(0);
+        logger.fine("deleting participant:" + participant);
        getTournamentDecorator().deleteParticipant(participant);
    }

+    /**
+     * Closes the participant form
+     */
    @FXML
-    void close(ActionEvent event) {
-        removeListener();
+    void close() {
        getFactoryDecorator().openScheduleView();
    }

+    /**
+     * Loads the previously saved content and puts it in the list
+     */
    @Override
    public void loadContent() {
-        participantListView.setItems(getTournamentDecorator().getTournament().getParticipants());
+        logger.fine("loading and placing it into the list");
+        Tournament tournament = getTournamentDecorator().getTournament();
+        if(tournament != null){
+            participantListView.setItems(tournament.getParticipants());
+        } else {
+            participantListView.getItems().clear();
+        }
    }
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/placesAddFormular/PlacesFormularController.java
+++ b/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/placesAddFormular/PlacesFormularController.java
@ -2,30 +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 javafx.event.ActionEvent;
+import ch.zhaw.projekt2.turnierverwaltung.Tournament;
 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;
@ -33,6 +27,8 @@ public class PlacesFormularController extends FXController {
    @FXML
    private Button deleteBtn;

+    @FXML
+    private Label newPlaceTitle;

    @FXML
    private Label placeListTitle;
@ -49,36 +45,79 @@ 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) {
-        removeListener();
+    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() {
-        placeListView.setItems(getTournamentDecorator().getTournament().getPlaces());
+        logger.fine("Getting the Saved tournaments into the Places list");
+        Tournament tournament = getTournamentDecorator().getTournament();
+        if (tournament != null) {
+            placeListView.setItems(tournament.getPlaces());
+        } else {
+            placeListView.getItems().clear();
+        }
    }
 }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/tournamentList/AlertDelete.java
+++ b/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;
    }
--- a/app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/tournamentList/TournamentListController.java
+++ b/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());
@ -62,7 +71,6 @@ public class TournamentListController extends FXController {

    @FXML
    void openTournament(ActionEvent event) {
-        removeListener();
        FileIO.TournamentFile tournamentFile = tournamentListView.getSelectionModel().getSelectedItems().get(0);
        getFactoryDecorator().openTournament(tournamentFile);
    }
@ -70,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);
        }
--- a/app/src/main/resources/ch/zhaw/projekt2/turnierverwaltung/MainWindow.fxml
+++ b/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>
--- a/app/src/main/resources/ch/zhaw/projekt2/turnierverwaltung/gameScheduleView/Game.fxml
+++ b/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>
--- a/app/src/main/resources/ch/zhaw/projekt2/turnierverwaltung/gameScheduleView/GameSchedule.fxml
+++ b/app/src/main/resources/ch/zhaw/projekt2/turnierverwaltung/gameScheduleView/GameSchedule.fxml
@ -1,15 +1,29 @@
 <?xml version="1.0" encoding="UTF-8"?>

-<?import javafx.geometry.*?>
-<?import javafx.scene.control.*?>
-<?import javafx.scene.layout.*?>
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.CheckBox?>
+<?import javafx.scene.control.ScrollPane?>
+<?import javafx.scene.layout.BorderPane?>
+<?import javafx.scene.layout.HBox?>

-<BorderPane maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" minHeight="-Infinity" minWidth="-Infinity" prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/11.0.2" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView.GameScheduleController">
+<BorderPane maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" minHeight="-Infinity" minWidth="-Infinity" prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/18" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView.GameScheduleController">
+   <center>
+      <ScrollPane maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" prefHeight="200.0" prefWidth="200.0" BorderPane.alignment="CENTER">
+         <content>
+            <HBox fx:id="hBoxCenter" maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" prefHeight="324.0" prefWidth="600.0" />
+         </content>
+      </ScrollPane>
+   </center>
   <top>
-      <HBox alignment="TOP_RIGHT" prefHeight="100.0" prefWidth="200.0" BorderPane.alignment="CENTER">
+      <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" />
-            <Button fx:id="createScheduleBtn" mnemonicParsing="false" onAction="#createNewSchedule" text="Create New Game Schedule">
+            <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>
+            </CheckBox>
+            <Button fx:id="createScheduleBtn" mnemonicParsing="false" onAction="#createNewSchedule" text="Spielplan neu erstellen">
               <HBox.margin>
                  <Insets right="20.0" />
               </HBox.margin>
@ -24,18 +38,12 @@
                  <Insets right="20.0" />
               </HBox.margin>
            </Button>
-            <Button fx:id="closeTournamentBtn" layoutX="470.0" layoutY="10.0" mnemonicParsing="false" onAction="#closeTournament" text="Close Tournament">
+            <Button fx:id="closeTournamentBtn" mnemonicParsing="false" onAction="#closeTournament" text="Close Tournament">
               <HBox.margin>
                  <Insets right="20.0" />
-               </HBox.margin></Button>
+               </HBox.margin>
+            </Button>
         </children>
      </HBox>
   </top>
-   <center>
-      <ScrollPane maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" prefHeight="200.0" prefWidth="200.0" BorderPane.alignment="CENTER">
-         <content>
-            <HBox fx:id="hBoxCenter" maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" prefHeight="324.0" prefWidth="600.0" />
-         </content>
-      </ScrollPane>
-   </center>
 </BorderPane>
--- a/app/src/main/resources/ch/zhaw/projekt2/turnierverwaltung/placesAddFormular/PlacesFormular.fxml
+++ b/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>
--- a/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/FactoryDecoratorTest.java
+++ b/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/FactoryDecoratorTest.java
@ -0,0 +1,38 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.Pane;
+import org.junit.jupiter.api.Test;
+import org.mockito.InOrder;
+import org.mockito.Mockito;
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static org.mockito.Mockito.inOrder;
+
+public class FactoryDecoratorTest {
+
+    private FactoryDecorator factoryDecorator;
+
+    @Test
+    void test() {
+        FileIO io = Mockito.mock(FileIO.class);
+        Factory fc = Mockito.mock(Factory.class);
+        Pane pn = Mockito.mock(BorderPane.class);
+        FileIO.TournamentFile tf = Mockito.mock(FileIO.TournamentFile.class);
+
+        factoryDecorator = new FactoryDecorator(io,fc,pn);
+        factoryDecorator.openTournament(tf);
+
+        InOrder order = inOrder(io,fc,pn);
+
+        try {
+            order.verify(fc).setTournament(io.loadTournament(tf));
+            order.verify(fc).showGameScheduler((BorderPane) pn);
+
+        } catch (IOException | ClassNotFoundException e) {
+            e.printStackTrace();
+            fail();
+        }
+    }
+}
--- a/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/FileIOTest.java
+++ b/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));
--- a/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/GameTest.java
+++ b/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/GameTest.java
@ -0,0 +1,41 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+public class GameTest {
+
+    private Game game;
+
+    @Test
+    @DisplayName("TestWinner")
+    void testWinnerFunction() {
+        Participant one = Mockito.mock(Player.class);
+        Participant two = Mockito.mock(Player.class);
+        game = new Game(one,two);
+        game.setPoints1(1);
+        Assertions.assertEquals(one,game.getWinner());
+        game.setPoints2(2);
+        Assertions.assertEquals(two,game.getWinner());
+    }
+
+    @Test
+    @DisplayName("Test refresh Participant")
+    void refreshTest() {
+        Participant one = Mockito.mock(Player.class);
+        Participant two = Mockito.mock(Player.class);
+        Game game1 = new Game(one,two);
+        Game game2 = new Game(one,two);
+        game = new Game(game1,game2);
+        game1.setPoints1(2);
+        game2.setPoints2(2);
+        Assertions.assertNull(game.getParticipant1());
+        Assertions.assertNull(game.getParticipant2());
+        game.refreshParticipants();
+        Assertions.assertEquals(one,game.getParticipant1());
+        Assertions.assertEquals(two,game.getParticipant2());
+
+    }
+}
--- a/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/LanguageTest.java
+++ b/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/LanguageTest.java
@ -0,0 +1,18 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class LanguageTest {
+
+    @Test
+    @DisplayName("Test Dictionary")
+    void test() {
+        LanguageConfigurator languageConfigurator = new LanguageConfigurator();
+        Assertions.assertEquals("Ja",languageConfigurator.getSelectedLanguage("yes"));
+        languageConfigurator.changeLanguage(LanguageConfigurator.Language.ENGLISH);
+        Assertions.assertEquals("Yes",languageConfigurator.getSelectedLanguage("yes"));
+
+    }
+}
--- a/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/PersonTest.java
+++ b/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/PersonTest.java
@ -0,0 +1,25 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class PersonTest {
+    private Person person;
+
+    @Test
+    @DisplayName("Test invalid Parameter")
+    void invalidParams() {
+        try {
+            assertThrows(Person.InvalidPhoneNumberException.class,()->new Person("A","a",".sad"));
+            person = new Person("A","A","");
+            assertEquals("A", person.getFirstName());
+            assertEquals("A", person.getName());
+            assertEquals("", person.getPhoneNumber());
+        } catch (InvalidNameException | Person.InvalidPhoneNumberException e) {
+            fail();
+        }
+    }
+
+}
--- a/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/PlaceTest.java
+++ b/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/PlaceTest.java
@ -0,0 +1,36 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class PlaceTest {
+    private Place place;
+
+    @Test
+    @DisplayName("Test Params")
+    void paramTest() {
+        Assertions.assertThrows(InvalidNameException.class, () -> new Place("*"));
+        try {
+            place = new Place("placeA");
+            assertEquals("placeA", place.getName());
+        } catch (InvalidNameException e) {
+            fail();
+        }
+    }
+
+    @Test
+    @DisplayName("Place Equals Test")
+    void testEqual() {
+        try {
+            place = new Place("placeA");
+            assertTrue(place.equals(place));
+            assertTrue(place.equals(new Place("placeA")));
+            assertFalse(place.equals(new Place("nads")));
+        } catch (InvalidNameException e) {
+            fail();
+        }
+    }
+}
--- a/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/PlayerTest.java
+++ b/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/PlayerTest.java
@ -0,0 +1,39 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class PlayerTest {
+    private Player player;
+
+    @Test
+    @DisplayName("Test invalid Parameter")
+    void invalidParams() {
+        try {
+            assertThrows(Person.InvalidPhoneNumberException.class,()->new Player("A","a",".sad",""));
+            assertThrows(Player.InvalidDateException.class,()->new Player("A","a","","a"));
+            player = new Player("A","A","","");
+            assertEquals("A",player.getFirstName());
+            assertEquals("A",player.getName());
+            assertEquals("",player.getPhoneNumber());
+            assertNull(player.getDateOfBirth());
+        } catch (InvalidNameException | Person.InvalidPhoneNumberException | Player.InvalidDateException e) {
+            fail();
+        }
+    }
+
+    @Test
+    @DisplayName("Test equals")
+    void equalsTest() {
+        try {
+            player = new Player("A","A","","");
+            assertTrue(player.equals(player));
+            assertFalse(player.equals(new Player("B", "D", "", "")));
+            assertTrue(player.equals(new Player("A", "A", "", "")));
+        } catch (InvalidNameException | Person.InvalidPhoneNumberException | Player.InvalidDateException e) {
+            e.printStackTrace();
+        }
+    }
+}
--- a/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/TeamTest.java
+++ b/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/TeamTest.java
@ -0,0 +1,31 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+public class TeamTest {
+
+    private Team team;
+
+    @Test
+    @DisplayName("Team Params")
+    void testParams() {
+        Player player = Mockito.mock(Player.class);
+        team = new Team("Team1");
+        for (int i = 0; i < 3; i++) {
+            Assertions.assertEquals(i,team.getPlayers().size());
+            team.addPlayer(player);
+        }
+    }
+
+    @Test
+    @DisplayName("Team Equals")
+    void equalTeam() {
+        team = new Team("A");
+        Assertions.assertTrue(team.equals(team));
+        Assertions.assertTrue(team.equals(new Team("A")));
+        Assertions.assertFalse(team.equals(new Team("B")));
+    }
+}
--- a/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/TournamentTest.java
+++ b/app/src/test/java/ch/zhaw/projekt2/turnierverwaltung/TournamentTest.java
@ -44,20 +44,21 @@ public class TournamentTest {
            //Checks if one Participant gets added
            Participant participantOne = Mockito.mock(Player.class);
            when(participantOne.equals(any(Participant.class))).thenReturn(false);
-
+            try {
                assertEquals(0, tournament.getParticipants().size());
                tournament.saveParticipant(participantOne);
                assertEquals(1, tournament.getParticipants().size());
-
                //Checks if a second Participant gets added
                Participant participantTwo = Mockito.mock(Player.class);
                tournament.saveParticipant(participantTwo);
                assertEquals(2, tournament.getParticipants().size());
-
                //Checks if a allready added Particpant does not get added
                when(participantOne.equals(any(Participant.class))).thenReturn(true);
                tournament.saveParticipant(participantTwo);
                assertEquals(2, tournament.getParticipants().size());
+            } catch (Person.InvalidPhoneNumberException e) {
+                fail();
+            }

        }

@ -69,13 +70,13 @@ public class TournamentTest {
            //Checks if Error is thrown if Participant not in list
            assertThrows(Tournament.ParticipantNotExistsException.class, () -> tournament.removeParticipant(participant));

+            try {
                //Checks if participant gets removed
                tournament.saveParticipant(participant);
                assertEquals(1, tournament.getParticipants().size());
-            try {
                tournament.removeParticipant(participant);
                assertEquals(0, tournament.getParticipants().size());
-            } catch (Tournament.ParticipantNotExistsException e) {
+            } catch (Tournament.ParticipantNotExistsException | Person.InvalidPhoneNumberException e) {
                fail();
            }
        }
@ -126,13 +127,18 @@ public class TournamentTest {
                        tournament.createGameSchedule();
                        assertEquals(2, tournament.getGameList().size());
                        tournament.saveParticipant(participant);
-                    } catch (Tournament.NumberOfParticipantInvalidException e) {
+                    } catch (Tournament.NumberOfParticipantInvalidException | Person.InvalidPhoneNumberException e) {
                        fail();
                    }

                } else {
+
                    assertThrows(Tournament.NumberOfParticipantInvalidException.class, () -> tournament.createGameSchedule());
+                    try {
                        tournament.saveParticipant(participant);
+                    } catch (Person.InvalidPhoneNumberException e) {
+                        e.printStackTrace();
+                    }
                }
            }
            try {
--- a/app/src/test/resources/ch/zhaw/projekt2/turnierverwaltung/FileIORead/saves/test1.txt
+++ b/app/src/test/resources/ch/zhaw/projekt2/turnierverwaltung/FileIORead/saves/test1.txt
Author	SHA1	Message	Date
Marcela Ruiz	7817c91546	Feedback Ruiz Dear Angry Nerds Team. Here you are the feedback for your project. BTW: Very good your application offer English and German language!	2022-05-26 20:05:07 +02:00
Roman Schenk	86b57547cf	Merge pull request #57 from PM2-IT21bWIN-ruiz-mach-krea/logging_and_docs Logging and docs	2022-05-13 23:57:50 +02:00
Andrin Fassbind	631ea90225	Merge remote-tracking branch 'origin/main'	2022-05-13 23:57:41 +02:00
Andrin Fassbind	30afecb379	javadoc	2022-05-13 23:57:31 +02:00
Leonardo Brandenberger	b52fbb6d55	Merge remote-tracking branch 'origin/main'	2022-05-13 23:56:37 +02:00
Leonardo Brandenberger	c11d6f8ef7	Last javadoc and logger implemented	2022-05-13 23:56:26 +02:00
Roman Schenk	d23d8cef74	Merge pull request #56 from PM2-IT21bWIN-ruiz-mach-krea/testing fixed FileIO Test.	2022-05-13 23:54:59 +02:00
schrom01	5ed0f38db6	fixed FileIO Test.	2022-05-13 23:54:27 +02:00
schrom01	6f043e7925	javadocs in TournamentDecorator.java	2022-05-13 23:49:18 +02:00
Leonardo Brandenberger	1aa05d6251	Merge remote-tracking branch 'origin/main'	2022-05-13 23:48:38 +02:00
Leonardo Brandenberger	73ba3b3b9e	Created Readme	2022-05-13 23:48:13 +02:00
fassband	b598eb660b	Merge pull request #55 from PM2-IT21bWIN-ruiz-mach-krea/testing Testing	2022-05-13 23:48:11 +02:00
Andrin Fassbind	ec256d40c6	FactoryDecoratorTest	2022-05-13 23:47:06 +02:00
Andrin Fassbind	2a8caf8efd	FactoryDecoratorTest	2022-05-13 23:45:49 +02:00
schrom01	7f2776d49d	javadocs in FactoryDecorator.java	2022-05-13 23:31:06 +02:00
schrom01	003f065662	fixed merge problem.	2022-05-13 23:29:39 +02:00
Roman Schenk	186c389bd2	uploaded new ClassDiagram	2022-05-13 23:04:17 +02:00
Roman Schenk	9f745b3198	Merge pull request #54 from PM2-IT21bWIN-ruiz-mach-krea/testing Testing	2022-05-13 23:03:37 +02:00
Andrin Fassbind	4db2c582e2	merge conflict	2022-05-13 23:03:15 +02:00
Roman Schenk	4392fabc38	Merge branch 'main' into testing	2022-05-13 22:59:35 +02:00
Andrin Fassbind	a8a2a0a463	create FactoryTest merged	2022-05-13 22:56:24 +02:00
Roman Schenk	caa21c8aa0	Merge pull request #53 from PM2-IT21bWIN-ruiz-mach-krea/logging_and_docs Logging and docs added in several classes #27 #28	2022-05-13 22:54:03 +02:00
schrom01	7114097601	fixed merge problem.	2022-05-13 22:53:49 +02:00
Andrin Fassbind	418f583955	Merge remote-tracking branch 'origin/logging_and_docs' into testing # Conflicts: # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Factory.java # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FactoryDecorator.java # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/LogConfiguration.java # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindow.java # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/MainWindowController.java # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/AlertNewSchedule.java # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/main/gameScheduleView/GameController.java	2022-05-13 22:53:30 +02:00
Roman Schenk	bbaf70f9af	Merge branch 'main' into logging_and_docs	2022-05-13 22:52:07 +02:00
Leonardo Brandenberger	56030d0baa	Merge remote-tracking branch 'origin/logging_and_docs' into logging_and_docs	2022-05-13 22:43:07 +02:00
Leonardo Brandenberger	52b79ed501	PlacesFormularController JavaDoc and Logger	2022-05-13 22:42:51 +02:00
schrom01	92360ad607	finished javadocs in Factory.java	2022-05-13 22:41:42 +02:00
schrom01	30ae77a11d	java docs in Factory.java	2022-05-13 22:35:05 +02:00
Andrin Fassbind	7f8de3e8f1	create FactoryTest	2022-05-13 22:35:01 +02:00
Andrin Fassbind	df3fc5df2d	create TeamTest	2022-05-13 22:22:39 +02:00
Leonardo Brandenberger	f94572c1fe	Fixed small logger error	2022-05-13 22:13:50 +02:00
Leonardo Brandenberger	023cb5a99f	Added MainWindow and MainWindowController javadoc and logger	2022-05-13 22:11:03 +02:00
Leonardo Brandenberger	784cbfdd76	Added MainWindow and MainWindowController javadoc and logger	2022-05-13 22:10:41 +02:00
schrom01	aee3549669	uploaded ClassDiagram.png	2022-05-13 22:08:20 +02:00
Andrin Fassbind	2e314497db	create PlaceTest	2022-05-13 22:06:58 +02:00
Andrin Fassbind	fd06e24e21	create PersonTest	2022-05-13 21:54:21 +02:00
Andrin Fassbind	2ef4c3f584	create PlayerTest	2022-05-13 21:46:31 +02:00
Leonardo Brandenberger	c7d9fd0908	FileIOTest Java Doc and also started with Factory and Factory Decorator	2022-05-13 21:15:31 +02:00
Andrin Fassbind	135ec7e8d5	sync TournamentTest with new changes create GameTest	2022-05-13 21:11:33 +02:00
Andrin Fassbind	c8eff00e33	Merge remote-tracking branch 'origin/main' into testing	2022-05-13 20:54:58 +02:00
fassband	9e599014ec	Merge pull request #52 from PM2-IT21bWIN-ruiz-mach-krea/language_Dev Language dev	2022-05-13 20:54:30 +02:00
Andrin Fassbind	ac68af3638	extend dictionary	2022-05-13 20:53:33 +02:00
Andrin Fassbind	c086cf18a4	test game	2022-05-13 19:41:20 +02:00
Andrin Fassbind	d530d89db4	edit layout	2022-05-13 19:20:07 +02:00
Andrin Fassbind	ddae1e297f	solve bug PlacesFormularController id name not valid	2022-05-13 19:18:51 +02:00
Leonardo Brandenberger	459cd1bec8	Code Cleanup and Java Doc and logging	2022-05-13 19:09:51 +02:00
Andrin Fassbind	1b22506047	solve bug game teilnehmername	2022-05-13 19:00:08 +02:00
Andrin Fassbind	dc54eaa872	Merge remote-tracking branch 'origin/main' into language_Dev	2022-05-13 18:57:39 +02:00
Andrin Fassbind	c4f0a5335d	Create Language Change	2022-05-13 18:57:27 +02:00
Leonardo Brandenberger	b49ca9172d	Code Cleanup in fileio, invalidnameexception and observers	2022-05-13 18:36:08 +02:00
Leonardo Brandenberger	6de4978145	Java Doc, Logging and Cleanup in Log Configuration.	2022-05-13 18:21:52 +02:00
Leonardo Brandenberger	3c3c6c8510	Merge pull request #51 from PM2-IT21bWIN-ruiz-mach-krea/develop_footer Develop footer	2022-05-13 17:52:44 +02:00
schrom01	a1b73e22ca	removed "äöü" from error messages.	2022-05-13 17:51:04 +02:00
Roman Schenk	2327573581	Merge pull request #50 from PM2-IT21bWIN-ruiz-mach-krea/logging_and_docs Logging and docs added to classes Person, Place and Player #27 #28	2022-05-13 17:49:39 +02:00
Leonardo Brandenberger	7fd058a528	CodeCleanup in Player, Tournament, Place, Person, Participant and Team	2022-05-13 17:48:42 +02:00
Leonardo Brandenberger	f38b8aff16	CodeCleanup in Player, Tournament and Participant	2022-05-13 17:16:33 +02:00
schrom01	11d6ca1852	changed error Message numberOfParticipants.	2022-05-13 17:10:32 +02:00
Leonardo Brandenberger	67003ad772	CodeCleanup in Player, Tournament and Participant	2022-05-13 17:03:23 +02:00
schrom01	a78d1d9de7	changed error Message numberOfParticipants.	2022-05-13 16:51:17 +02:00
schrom01	5f6193d8b2	Merge branch 'main' into develop_footer # Conflicts: # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Tournament.java	2022-05-13 16:50:35 +02:00
Leonardo Brandenberger	e0a9d963f6	CodeCleanup in Participant, Person and Team	2022-05-13 16:43:33 +02:00
Roman Schenk	f8d12dafa7	Merge branch 'main' into logging_and_docs	2022-05-13 16:39:36 +02:00
Leonardo Brandenberger	726410f677	Added Java Doc and Logger to Person	2022-05-13 16:12:55 +02:00
Roman Schenk	3d522dd13c	Merge pull request #49 from PM2-IT21bWIN-ruiz-mach-krea/gameSchedule_Alert Create alert popup if user wants to create new game schedule	2022-05-13 16:12:29 +02:00
Andrin Fassbind	7dea7919c5	AlertDelete shortened code	2022-05-13 16:12:06 +02:00
fassband	f575bb94d3	Merge pull request #48 from PM2-IT21bWIN-ruiz-mach-krea/fixes_in_layout Fixes in layout	2022-05-13 16:06:23 +02:00
Andrin Fassbind	55517a531e	Create alert popup if user wants to create new game schedule	2022-05-13 16:04:19 +02:00
schrom01	53cf3bdacc	rmeoved tournament Type GROUPS from Tournament Enum Type.	2022-05-13 15:58:58 +02:00
schrom01	c862492be3	fixes in Layout solved #34	2022-05-13 15:57:39 +02:00
fassband	a6f14b94bd	Merge pull request #47 from PM2-IT21bWIN-ruiz-mach-krea/fix_places_are_deleted_ fixed places are deleted.	2022-05-13 15:38:42 +02:00
Roman Schenk	d3472017bb	Merge pull request #46 from PM2-IT21bWIN-ruiz-mach-krea/closeImplementation Make Application close properly	2022-05-13 15:37:31 +02:00
schrom01	0a7ca1ac3e	fixed places are deleted. solved #45	2022-05-13 15:36:29 +02:00
Andrin Fassbind	bdb34fde31	Make Application close properly If exception while closing there is a proper log	2022-05-13 15:35:41 +02:00
Roman Schenk	20903f6a69	Merge pull request #44 from PM2-IT21bWIN-ruiz-mach-krea/refactoring_of_factory refactoring of Factory.java	2022-05-13 15:17:15 +02:00
Roman Schenk	e9d42b719b	Merge branch 'main' into refactoring_of_factory	2022-05-13 15:16:51 +02:00
Roman Schenk	1d6fcce13f	Merge pull request #42 from PM2-IT21bWIN-ruiz-mach-krea/testClass Test class	2022-05-13 15:16:05 +02:00
schrom01	6c761c944f	refactoring of Factory.java added Enum View solved #23	2022-05-13 15:08:26 +02:00
schrom01	54a428cde2	throw PlaceExistsExceptoin if place exists already.	2022-05-13 13:48:38 +02:00
Leonardo Brandenberger	7267fe590b	Added Java Doc and Logger to Place.java	2022-05-13 01:48:26 +02:00
Leonardo Brandenberger	befa159f90	Added Java Doc and Logger to Player	2022-05-13 01:36:54 +02:00
Leonardo Brandenberger	06003d5b54	Merge remote-tracking branch 'origin/logging_and_docs' into logging_and_docs	2022-05-13 00:07:17 +02:00
Leonardo Brandenberger	072db996dc	Added Java Doc and Logger to Team	2022-05-13 00:02:31 +02:00