Feedback Ruiz

Dear Angry Nerds Team. 

Here you are the feedback for your project. BTW: Very good your application offer English and German language!

README.md

@@ -1 +1,70 @@
-# team02-AngryNerds-projekt2-turnierverwaltung
+# 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)
+

app/build.gradle

@@ -26,6 +26,8 @@ dependencies {
     // Use JUnit Jupiter for testing.
     testImplementation 'org.junit.jupiter:junit-jupiter:5.8.1'
 
+    testImplementation 'org.mockito:mockito-core:4.3.+'
+
     // This dependency is used by the application.
     implementation 'com.google.guava:guava:30.1.1-jre'
 
@@ -37,7 +39,9 @@ application {
     mainClass = 'ch.zhaw.projekt2.turnierverwaltung.App'
 }
 
-tasks.named('test') {
+test {
     // Use JUnit Platform for unit tests.
     useJUnitPlatform()
+
+
 }

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

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

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

@@ -7,41 +7,75 @@ public abstract class FXController {
     FactoryDecorator factoryDecorator;
     FileIO fileIO;
     Pane pane;
+    IsObserver listener;
+    LanguageConfigurator languageConfigurator;
 
-    public void setup(TournamentDecorator tournamentDecorator, FileIO fileIO, FactoryDecorator factoryDecorator, Pane pane){
+    public FXController() {
+        listener = new IsObserver() {
+            @Override
+            public void update() {
+                loadContent();
+            }
+        };
+    }
+
+    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;
-        tournamentDecorator.addListener(new IsObserver() {
+        this.languageConfigurator = languageConfigurator;
-            @Override
+        shareGUIElementWithLanguageConfigurator();
-            public void update() {
+        addListener();
-                loadContent();
-            }
-        });
-        factoryDecorator.addListener(new IsObserver() {
-            @Override
-            public void update() {
-                loadContent();
-            }
-        });
     }
 
+    public abstract void shareGUIElementWithLanguageConfigurator();
+
     public abstract void loadContent();
 
+    protected void setTournamentDecorator(TournamentDecorator tournamentDecorator) {
+        this.tournamentDecorator = tournamentDecorator;
+    }
+
+    public void addListener() {
+        tournamentDecorator.addListener(listener);
+        factoryDecorator.addListener(listener);
+    }
+
     protected TournamentDecorator getTournamentDecorator() {
         return tournamentDecorator;
     }
 
+    protected void setFactoryDecorator(FactoryDecorator factoryDecorator) {
+        this.factoryDecorator = factoryDecorator;
+    }
+
     protected FactoryDecorator getFactoryDecorator() {
         return factoryDecorator;
     }
 
+    protected void setFileIO(FileIO fileIO) {
+        this.fileIO = fileIO;
+    }
+
     protected FileIO getFileIO() {
         return fileIO;
     }
 
+    protected void setPane(Pane pane) {
+        this.pane = pane;
+    }
+
     protected Pane getPane() {
         return pane;
     }
+
+    protected LanguageConfigurator getLanguageConfigurator() {
+        return languageConfigurator;
+    }
 }

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

@@ -1,75 +1,243 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
-import ch.zhaw.projekt2.turnierverwaltung.main.tournamentList.TournamentListController;
+import ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView.GameController;
+import ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView.GameDecorator;
 import javafx.fxml.FXMLLoader;
-import javafx.scene.layout.BorderPane;
+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.util.logging.Logger;
 
+/**
+ * Class to load the views from FXML Files and switch between the views.
+ */
 public class Factory {
     private TournamentDecorator tournamentDecorator;
     private FileIO fileIO;
+    private static LanguageConfigurator languageConfigurator;
 
-    public Factory(FileIO fileIO, TournamentDecorator tournamentDecorator){
+    private static final Logger logger = Logger.getLogger(Factory.class.getCanonicalName());
+
+    /**
+     * Contructor to create Factory instance.
+     * @param fileIO the fileIO instance which saves and reads the tournament from files.
+     * @param tournamentDecorator the touramanetDecorator class to access the tournament.
+     */
+    public Factory(FileIO fileIO, TournamentDecorator tournamentDecorator, LanguageConfigurator languageConfigurator) {
         this.fileIO = fileIO;
         this.tournamentDecorator = tournamentDecorator;
+        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);
     }
 
-    public BorderPane loadMainWindow(){
+    /**
-        FXMLLoader loader = new FXMLLoader(getClass().getResource("mainWindow.fxml"));
+     * 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"));
         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){
+    /**
-        tournamentDecorator.setTournament(null);
+     * Class which loads all views of Enum View
-        TournamentListController controller = (TournamentListController) setCenterOfBorderPane(pane, getClass().getResource("tournamentList/tournamentList.fxml"), factoryDecorator);
+     * @param factoryDecorator the FactoryDecorator which is used to setup the controller.
-    }
+     * @param pane the pane where the loaded view will be visible
-
+     */
-    //Can be used to Open new Scene in same Stage.
+    public void loadAllViews(FactoryDecorator factoryDecorator, BorderPane pane){
-    //This way possible to later give object to Controller
+        for(View view : View.values()){
-    public void loadParticipantFormular(BorderPane pane, FactoryDecorator factoryDecorator) {
+            try {
-        setCenterOfBorderPane(pane, getClass().getResource("participantAddFormular/participantFormular.fxml"), factoryDecorator);
+                view.loadView(tournamentDecorator, fileIO, factoryDecorator, pane);
-    }
+            } catch (IOException e) {
-
+                e.printStackTrace();
-    public void loadPlacesFormular(BorderPane pane, FactoryDecorator factoryDecorator) {
+                logger.warning("failed to load views.");
-        setCenterOfBorderPane(pane, getClass().getResource("placesAddFormular/PlacesFormular.fxml"), factoryDecorator);
+            }
-    }
-
-    public void loadGameScheduler(BorderPane pane, FactoryDecorator factoryDecorator) {
-        setCenterOfBorderPane(pane, getClass().getResource("gameScheduleView/GameSchedule.fxml"), factoryDecorator);
-    }
-
-    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);
-            controller.loadContent();
-        } catch (IOException e) {
-            e.printStackTrace();
-            //TODO handle and logging?
         }
-        return controller;
+    }
+
+    /**
+     * Method to show the view TournamentList
+     * @param pane the Pane where the View will be visible
+     */
+    public void showTournamentList(BorderPane pane) {
+        tournamentDecorator.setTournament(null);
+        setCenterOfBorderPane(pane, View.tournamentList);
+        logger.fine("showing Tournament List");
+    }
+
+    /**
+     * 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");
+    }
+
+    /**
+     * 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");
+    }
+
+    /**
+     * 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, languageConfigurator);
+            logger.fine("loaded game view");
+            return controller;
+        } catch (IOException e) {
+            logger.warning("Fatal error program can not continue after this: " + e );
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * Method to print information for the user to the footer of mainwindow.
+     * @param pane the pane where the footer should be shown.
+     * @param msg the text to show.
+     * @param error true if it's a error message.
+     */
+    public void printMessageToFooter(BorderPane pane, String msg, boolean error) {
+        logger.fine("message is printed to footer of window.");
+        VBox bottom = (VBox) pane.getBottom();
+        Label label = new Label();
+        VBox innerVbox;
+        label.setText(msg);
+
+        if (error) {
+            innerVbox = (VBox) bottom.getChildren().get(0);
+            resetFooter(pane, true);
+            label.setTextFill(Color.RED);
+            label.setFont(new Font(20));
+            innerVbox.setBorder(new Border(new BorderStroke(Color.valueOf("#FF0000"), BorderStrokeStyle.SOLID, CornerRadii.EMPTY, BorderWidths.DEFAULT)));
+            innerVbox.getChildren().add(label);
+
+        } else {
+            innerVbox = (VBox) bottom.getChildren().get(1);
+            resetFooter(pane,false);
+            label.setTextFill(Color.GREEN);
+            label.setFont(new Font(10));
+            label.setPadding(new Insets(0,10,0,0));
+            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) {
+            vBox = (VBox) bottom.getChildren().get(0);
+        } else {
+            vBox = (VBox) bottom.getChildren().get(1);
+        }
+        vBox.getChildren().clear();
+        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);
+        }
+
+    }
 
 }

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

@@ -1,72 +1,291 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
+import ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView.GameController;
+import ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView.GameDecorator;
+import javafx.geometry.Pos;
 import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.HBox;
 import javafx.scene.layout.Pane;
+import javafx.scene.layout.VBox;
+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));
-            factory.loadGameScheduler((BorderPane) pane, this);
+            openScheduleView();
-            informListener();
+            clearMessage(false);
-        } catch (IOException e) {
+            logger.fine("Opened tournament file successfully");
+        } catch (IOException | ClassNotFoundException e) {
             e.printStackTrace();
-        } catch (ClassNotFoundException e) {
+            logger.warning("Failed to open tournament file Error: " + e);
-            e.printStackTrace();
+            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);
+        }
     }
 
-    public void openParticipantFormular() {
+    /**
-        factory.loadParticipantFormular((BorderPane) pane, this);
+     * Initializes the display of the Tournament list view
+     */
+    public void openTournamentList() {
+        logger.fine("Showing TournamentList view");
+        factory.showTournamentList((BorderPane) pane);
+        informListener();
     }
 
-    public void openPlacesFormular() {
+    /**
-        factory.loadPlacesFormular((BorderPane) pane, this);
+     * Initializes the view of the participant form
+     */
+    public void openParticipantForm() {
+        logger.fine("Showing participant form view");
+        factory.showParticipantFormular((BorderPane) pane);
+        informListener();
     }
 
+    /**
+     * 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<>();
+        double gameBoxHeight = 0;
+        double spacingFactor = 0;
+        for (int i = 0; i < gameList.size(); i++) {
+            List<GameDecorator> newGameDecoratorsList = new ArrayList<>();
+            VBox vBox = new VBox();
+            if (treeView) {
+                vBox.setAlignment(Pos.CENTER);
+                vBox.setSpacing(gameBoxHeight * spacingFactor);
+            } else {
+                vBox.setAlignment(Pos.TOP_CENTER);
+            }
+            spacingFactor = spacingFactor * 2 + 1;
+            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.getGameBoxHeight();
+                }
+                gameDecorator.addListener(new IsObserver() {
+                    @Override
+                    public void update() {
+                        tournamentDecorator.saveTournament();
+                    }
+                });
+                gameController.loadContent();
+            }
+            hBoxCenter.getChildren().add(vBox);
+            if (treeView) {
+                if (i + 1 < gameList.size())
+                    hBoxCenter.getChildren().add(drawLines(vBox, gameBoxHeight, 30));
+            }
+            gameDecoratorsList = newGameDecoratorsList;
+        }
+    }
+
+    /**
+     * 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) {
+            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));
+            lineBox.getChildren().add(vBox);
+
+
+            //add vertical line
+            lineBox.getChildren().add(new Line(0, 0, 0, lineSpacing));
+
+            //add line to right game
+            lineBox.getChildren().add(new Line(0, 0, lineLength, 0));
+
+            completeLineVBox.getChildren().add(lineBox);
+
+
+        }
+        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);
+    }
+
+    /**
+     * Method that initializes a new Message to be written on the footer, if it's an error boolean can be set.
+     *
+     * @param msg The message to be written
+     * @param error true if an error false if not
+     */
+    public void printMessageToFooter(String msg, boolean error) {
+        logger.fine("Initializes to write message: " + msg + " on the footer");
+        factory.printMessageToFooter((BorderPane) pane, msg, error);
+    }
+
+    /**
+     * Method used to clear Messages shown on the footer
+     * @param error true if an error false if not
+     */
+    public void clearMessage(boolean error) {
+        logger.fine("Initializing to clear messages from the footer");
+        factory.resetFooter((BorderPane) pane, error);
+    }
+
+    /**
+     * getter Method of languageConfigurator
+     * @return the languageConfigurator object.
+     */
+    public LanguageConfigurator getLanguageConfigurator() {
+        return factory.getLanguageConfigurator();
+    }
+
+    /**
+     * Method that informs all listeners of an update.
+     */
     public void informListener() {
-        for(IsObserver observer : listener) {
+
+        for (IsObserver observer : listener) {
             observer.update();
         }
     }

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

@@ -4,7 +4,14 @@ package ch.zhaw.projekt2.turnierverwaltung;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
 
-import java.io.*;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.net.URI;
 import java.util.logging.Logger;
 
@@ -12,8 +19,8 @@ import java.util.logging.Logger;
  * Class in Charge of Reading and Writing files
  */
 public class FileIO {
-    private File mainDir;
+    private final File mainDir;
-    private File saves;
+    private final File saves;
 
     private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
 
@@ -57,13 +64,14 @@ public class FileIO {
 
     /**
      * Method to check if a tournament with the existing name already exists.
+     *
      * @param name that is being checked
      * @return true if the name exists already false if the name is unique
      */
     public boolean tournamentExists(String name) {
         logger.finer("checking for duplicate name in tournament List");
         for (TournamentFile file : getList()) {
-            if (file.toString().toLowerCase().equals(name.toLowerCase())) {
+            if (file.toString().equalsIgnoreCase(name)) {
                 logger.fine(name + " is an already existing name in the list");
                 return true;
             }
@@ -73,15 +81,15 @@ 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
      */
-    public Tournament loadTournament(File tournamentFile) throws IOException, ClassNotFoundException, FileNotFoundException {
+    public synchronized Tournament loadTournament(File tournamentFile) throws IOException, ClassNotFoundException, FileNotFoundException {
         if (tournamentFile == null) {
             logger.warning("Given tournament file is empty");
             throw new IllegalArgumentException("Tournament File is null");
@@ -119,13 +127,13 @@ 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
      * @throws FileNotFoundException File not found
      */
-    public void saveTournament(Tournament tournament) throws IOException, FileNotFoundException {
+    public synchronized void saveTournament(Tournament tournament) throws IOException, FileNotFoundException {
         if (tournament == null) {
             logger.warning("Given tournament file is empty");
             throw new IllegalArgumentException("Null tournament received");
@@ -181,14 +189,14 @@ public class FileIO {
     }
 
     /**
-     * TournamentFile Class is in use to add missing functionality that is
+     * TournamentFile Class is in used to add missing functionality that is
      */
-    public class TournamentFile extends File {
+    public static class TournamentFile extends File {
 
         /**
          * Only job the constructor got is to initialize it via its superclass. See java.io.File Documentation for more info.
          *
-         * @param uri abstract pathname needed for its superclass to intialize the file accordingly.
+         * @param uri abstract pathname needed for its superclass to initialize the file accordingly.
          */
         public TournamentFile(URI uri) {
             super(uri);

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

@@ -1,49 +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 Participant participant1, participant2;
     private int points1, points2;
     private Place place;
+    private Game previousGame1, previousGame2;
 
-    public Place getLocation() {
+    private static final Logger logger = Logger.getLogger(Game.class.getCanonicalName());
-        return place;
+
+    /**
+     * 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 void setLocation(Place place) {
+    /**
-        this.place = place;
+     * Constructor to initialize a game with two previous games.
+     *
+     * @param previousGame1 previous game (connecting to this game in the hierarchy)
+     * @param previousGame2 other previous game (connecting to this game in the hierarchy)
+     */
+    public Game(Game previousGame1, Game previousGame2) {
+        logger.fine("initializing a new game with the previous games: " + previousGame1 + ", " + previousGame2);
+        this.previousGame1 = previousGame1;
+        this.previousGame2 = previousGame2;
     }
 
+    /**
+     * Method to get the points of the first participant
+     *
+     * @return points of participant 1
+     */
     public int getPoints1() {
+        logger.fine("Returning points of: " + participant1 + ", holding: " + points1 + " points");
         return points1;
     }
 
+    /**
+     * Method to set the points of the first participant
+     *
+     * @param points1 to be set for the first participant
+     */
     public void setPoints1(int points1) {
+        logger.fine("Setting points of: " + participant1 + ", to " + points1 + " points");
         this.points1 = points1;
     }
 
+    /**
+     * Method to get the points of the second participant
+     *
+     * @return points of participant 2
+     */
     public int getPoints2() {
+        logger.fine("Returning points of: " + participant2 + ", holding: " + points2 + " points");
         return points2;
     }
 
+    /**
+     * Method to set the points of the second participant
+     *
+     * @param points2 to be set for the second participant
+     */
     public void setPoints2(int points2) {
+        logger.fine("Setting points of: " + participant2 + ", to " + points2 + " points");
         this.points2 = points2;
     }
 
+    /**
+     * Method to get the first Participant
+     *
+     * @return the first Participant
+     */
     public Participant getParticipant1() {
+        logger.fine("Returning the first participant: " + participant1);
         return participant1;
     }
 
+    /**
+     * Method to set the first participant
+     *
+     * @param participant1 to be set as the first participant
+     */
     public void setParticipant1(Participant participant1) {
+        logger.fine("Setting the first Participant as: " + participant1);
         this.participant1 = participant1;
     }
 
-    public Participant getParticipant2() {
+    /**
-        return Participant2;
+     * 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;
     }
 
-    public void setParticipant2(Participant participant2) {
+    /**
-        Participant2 = participant2;
+     * Method to get the second Participant
+     *
+     * @return the second participant
+     */
+    public Participant getParticipant2() {
+        logger.fine("Returning the second participant: " + participant2);
+        return participant2;
     }
+
+    /**
+     * Method to set the place of a game
+     *
+     * @param place to be set for the game
+     */
+    public void setPlace(Place place) {
+        logger.fine("Setting the location of the game " + this + " to: " + place);
+        this.place = place;
+    }
+
+    /**
+     * Method to get the place of a game
+     *
+     * @return the place of the game
+     */
+    public Place getPlace() {
+        logger.fine("Returning the place of the game, current Location: " + place);
+        return place;
+    }
+
+    /**
+     * Method to determine the winner of a game, if there is a draw null will be returned.
+     *
+     * @return the winner of the game or null if draw
+     */
+    public Participant getWinner() {
+        logger.finer("Determining winner of game");
+        if (points1 > points2) {
+            logger.fine(participant1 + "has won the game");
+            return participant1;
+        } else if (points2 > points1) {
+            logger.fine(participant2 + "has won the game");
+            return participant2;
+        } else {
+            logger.fine("There is no winner");
+            return null;
+        }
+    }
+
+    /**
+     * Method that gets the winner of previous games and sets them as the participants of this game.
+     */
+    public void refreshParticipants() {
+        participant1 = previousGame1.getWinner();
+        participant2 = previousGame2.getWinner();
+        logger.fine("Refreshed Participants, new Participants: " + participant1 + ", " + participant2);
+    }
+
 }

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

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

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

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

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

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

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/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
+    }
+}

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") +
+        logger.fine("Getting and reading log config file from: " + propertiesPath);
-                "turnierverwaltung" + System.getProperty("file.separator") + "logging" + System.getProperty("file.separator") + "log.properties";
-
-        logger.fine("Getting and reading logconfig file from " + propertiesPath);
         InputStream logConfig = this.getClass().getClassLoader().getResourceAsStream(propertiesPath);
         LogManager.getLogManager().readConfiguration(logConfig);
 
-
         Logger.getLogger(LogConfiguration.class.getPackageName());
+        logger.fine("Finished setting up Logging functionality");
     }
 }

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

@@ -2,8 +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);
+
+    /**
+     * Method to  change out participants
+     *
+     * @param participant to be exchanged
+     * @throws Person.InvalidPhoneNumberException if phone number does not follow the correct formatting
+     */
+    void change(Participant participant) throws Person.InvalidPhoneNumberException;
 }

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

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

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

@@ -1,21 +1,78 @@
 package ch.zhaw.projekt2.turnierverwaltung;
 
-public class Place {
+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)){
+        if (!name.matches(NAME_MATCHING_REGEX)) {
-            throw new InvalidNameException("The Name is Invalid.");
+            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() {
+        return name;
+    }
+
+    /**
+     * 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) {
+    }
 }

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

@@ -1,40 +1,131 @@
 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;
 
-    public Player(String firstName, String name, String phoneNumber, String dateOfBirth) throws InvalidNameException, InvalidPhoneNumberException {
+    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 "";
         }
     }
 
-    public void setDateOfBirth(String dateOfBirth) {
+
-        String[] date = dateOfBirth.split("\\.");
+    /**
-        this.dateOfBirth = LocalDate.of(Integer.valueOf(date[2]), Integer.valueOf(date[1]), Integer.valueOf(date[0]));
+     * 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 {
+        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.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 {
+            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) throws InvalidPhoneNumberException {
+        logger.fine("changing the current Player " + this + "with " + participant.getName());
+        Player player = (Player) participant;
+
+        setDateOfBirth(player.getDateOfBirth());
+        setPhoneNumber(player.getPhoneNumber());
+    }
+
+    public static class InvalidDateException extends Exception {
+        public InvalidDateException(String errorMessage) {
+            super(errorMessage);
+        }
+
+    }
+
 }

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

@@ -2,46 +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;
     }
 
-    @Override
+    /**
-    public boolean equals(Participant participant) {
+     * Method that sets a complete List of all players as players of the team
-        return getClass().equals(participant.getClass()) && toString().toLowerCase().equals(participant.toString().toLowerCase());
+     *
+     * @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().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) {
+    }
+
+    /**
+     * Method to get the current contact person of a team
+     *
+     * @return the current contact person
+     */
     public Person getContactPerson() {
+        logger.fine("Returning contact Person of team " + getName());
         return contactPerson;
     }
 
+    /**
+     * Method to set a Person as a contact person of a team
+     *
+     * @param contactPerson to be set
+     */
     public void setContactPerson(Person contactPerson) {
+        logger.fine("Setting " + contactPerson + " as a contact Person for team " + getName());
         this.contactPerson = contactPerson;
     }
 
+    /**
+     * Override of toString method, that returns the current name
+     *
+     * @return name in form of a String
+     */
     @Override
-    public String toString(){
+    public String toString() {
         return name;
     }
 }

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

@@ -3,167 +3,320 @@ package ch.zhaw.projekt2.turnierverwaltung;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
 
-import java.io.File;
 import java.io.Serializable;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
+import java.util.logging.Logger;
 
+
+/**
+ * Class used to represent a single tournament, participants place and games are placed in it
+ * For saving purposes it implements Serializable.
+ */
 public class Tournament implements Serializable {
     private String name;
     private Type type;
-    private List<Participant> participants;
+    private final List<Participant> participants;
-    private List<Place> places;
+    private final List<Place> places;
-
+    private List<List<Game>> gameList;
+
+    private static final Logger logger = Logger.getLogger(Tournament.class.getCanonicalName());
 
 
+    /**
+     * Constructor that initializes tournament with the needed parameters name and types, also checks if those
+     * parameters are valid and throws errors if not
+     *
+     * @param name name of the tournament
+     * @param type type of the Tournament, for example KO or Groupphase
+     * @throws InvalidNameException If name contains invalid characters
+     * @throws InvalidTypeException If the Type does not exist
+     */
     public Tournament(String name, Type type) throws InvalidNameException, InvalidTypeException {
-        if(!name.matches("[\\w]{1,20}")){
+        if (!name.matches("[\\w]{1,20}")) {
-            throw new InvalidNameException("Invalid Name entered"); //TODO handle en logging.
+            logger.warning("The entered name is incorrect, Entered name: " + name);
-        } else if(!Arrays.asList(Type.values()).contains(type)){
+            throw new InvalidNameException("Invalid Name entered");
-            throw new InvalidTypeException("Invalid Type selected"); //TODO handle en logging.
+        } else if (!Arrays.asList(Type.values()).contains(type)) {
+            logger.warning("The given Type is invalid and does not exist, Given Type: " + type);
+            throw new InvalidTypeException("Invalid Type selected");
         }
 
+        logger.fine("Setting up Tournament with name " + name + " and Type " + type);
         setName(name);
         setType(type);
+        logger.fine("Creating needed Lists for participants, places and games");
         participants = new ArrayList<>();
+        places = new ArrayList<>();
+        gameList = new ArrayList<>();
+        logger.fine("Successfully initialized tournament");
     }
 
-    public void addParticipant(Participant newParticipant) throws ParticipantExistsException {
+    /**
-        for(Participant participant : participants){
+     * Method used to save new Participant into the tournament, checking if participant already exists and if yes will
-            if(participant.equals(newParticipant)){
+     * edit the already existing participant
-                participants.remove(participant);
+     *
+     * @param newParticipant the Participant to be saved or edited
+     */
+    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)) {
+                logger.fine("matching participant: " + newParticipant +
+                        "found and instead of creating new one this one will be edited");
+                participant.change(newParticipant);
+                return;
             }
         }
+        logger.fine("Participant " + newParticipant + " being added to tournament.");
         participants.add(newParticipant);
     }
 
+    /**
+     * Method to remove an existing participant throws error if participant could not be found
+     *
+     * @param participant to be removed
+     * @throws ParticipantNotExistsException thrown when the participant could not be found
+     */
     public void removeParticipant(Participant participant) throws ParticipantNotExistsException {
-        if(!participants.contains(participant)){
+        logger.finer("Trying to remove " + participant + " from participants List");
-            throw new ParticipantNotExistsException("The given Participant is not part of this Tournament");
+        if (!participants.contains(participant)) {
+            logger.warning("Participant: " + participant + " could not be found");
+            throw new ParticipantNotExistsException("The given Participant (" + participant
+                    + ")is not part of this Tournament");
         }
+        logger.fine("Matching Participant could be found and is removed, participant name: " + participant);
         participants.remove(participant);
     }
 
+    /**
+     * Method to return an Observable List of all current participants
+     *
+     * @return ObservableList containing all current participants
+     */
     public ObservableList<Participant> getParticipants() {
+        logger.finer("Creates Observable list for participants");
         ObservableList<Participant> participantsObservable = FXCollections.observableArrayList();
+        logger.finer("Fills Observable List with all participants");
         participantsObservable.addAll(participants);
+        logger.fine("Returning Observable List containing all participants");
         return participantsObservable;
     }
 
-    public void addPlace(Place newPlace) throws PlaceExistsException {
+    /**
-        for(Place place : places){
+     * Method to add a new Place, also checks if place does already exist.
-            if(place.equals(newPlace)){
+     *
-                places.remove(place);
+     * @param newPlace to be added in the list of all places
+     */
+    public void savePlace(Place newPlace) {
+        for (Place place : places) {
+            if (place.equals(newPlace)) {
+                place.change(newPlace);
+                return;
             }
         }
         places.add(newPlace);
     }
 
+    /**
+     * 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)){
+        if (!places.contains(place)) {
             throw new PlaceNotExistsException("The given Place is not part of this Tournament");
         }
+        logger.fine("removing " + place + "from places");
         places.remove(place);
     }
 
+    /**
+     * Method returns an Observable list of all places
+     *
+     * @return a list of all places
+     */
     public ObservableList<Place> getPlaces() {
         ObservableList<Place> placesObservable = FXCollections.observableArrayList();
         placesObservable.addAll(places);
         return placesObservable;
     }
 
+
+    /*
+    Method creates a completely new GameSchedule
+     */
+    public void createGameSchedule() throws NumberOfParticipantInvalidException {
+        gameList = new ArrayList<>();
+        if (type == Type.KO) {
+            if (numberOfParticipantValid()) {
+                logger.fine("initiates a new calculation of the game schedule");
+                calcGameSchedule();
+            } else {
+                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");
+        }
+    }
+
+    /**
+     * Method to check if the number of participants is valid, returns true if yes and false if not
+     *
+     * @return boolean that returns if participant is valid
+     */
+    private boolean numberOfParticipantValid() {
+        double res = Math.log(participants.size()) / Math.log(2);
+        logger.fine("checks if value is 2^n and returns true if yes");
+        return (res * 10) % 10 == 0 && participants.size() >= 4;
+    }
+
+    /**
+     * Method that calculates a new game schedule
+     */
+    private void calcGameSchedule() {
+        logger.finer("uses shuffle of Collections to bring all participants in a random order");
+        Collections.shuffle(participants);
+
+        for (int i = 0; i < (Math.log(participants.size()) / Math.log(2)); i++) {
+            List<Game> gameRound = new ArrayList<>();
+            if (i == 0) {
+                for (int j = 0; j < participants.size() - 1; j += 2) {
+                    gameRound.add(new Game(participants.get(j), participants.get(j + 1)));
+                }
+            } else {
+                for (int j = 0; j < (gameList.get(i - 1).size() / 2); j++) {
+                    gameRound.add(new Game(gameList.get(i - 1).get(j * 2), gameList.get(i - 1).get(j * 2 + 1)));
+                }
+            }
+            logger.fine("Created new game tree");
+            gameList.add(gameRound);
+        }
+
+    }
+
+    /**
+     * Getter Method to return the name of the tournament
+     *
+     * @return the name of the tournament
+     */
     public String getName() {
+        logger.fine("Returning the name of the tournament, Name: " + name);
         return name;
     }
 
+    /**
+     * Setter method for the name of the tournament
+     *
+     * @param name the new name that should be set
+     */
     public void setName(String name) {
         this.name = name;
     }
 
+    /**
+     * Getter method to get the type of the tournament
+     *
+     * @return the type of the tournament
+     */
     public Type getType() {
+        logger.fine("Returning the type of the tournament");
         return type;
     }
 
+    /**
+     * Setter Method to set the type of the tournament
+     *
+     * @param type the type to be set
+     */
     public void setType(Type type) {
+        logger.fine("Setting the type of the tournament to: " + type);
         this.type = type;
     }
 
+    /**
+     * Getter method to get the Complete GameList
+     *
+     * @return the complete GameList
+     */
+    public List<List<Game>> getGameList() {
+        logger.fine("Returns the complete gameList");
+        return gameList;
+    }
+
+    /**
+     * Enum for all types of Tournaments
+     * (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;
         }
 
-        public static ObservableList<Type> getObservableList(){
+        /**
+         * 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());
             return items;
         }
     }
 
-    public class InvalidTypeException extends Exception {
+    /**
-        public InvalidTypeException() {
+     * Custom exception thrown when an invalid file is chosen
-            super();
+     */
-        }
+    public static class InvalidTypeException extends Exception {
-
         public InvalidTypeException(String errorMessage) {
             super(errorMessage);
         }
 
     }
 
-    public class ParticipantExistsException extends Exception {
+    /**
-        public ParticipantExistsException() {
+     * Custom Exception thrown when a Participant does not exist
-            super();
+     */
-        }
+    public static class ParticipantNotExistsException extends Exception {
-
-        public ParticipantExistsException(String errorMessage) {
-            super(errorMessage);
-        }
-
-    }
-
-    public class ParticipantNotExistsException extends Exception {
-        public ParticipantNotExistsException() {
-            super();
-        }
-
         public ParticipantNotExistsException(String errorMessage) {
             super(errorMessage);
         }
 
     }
 
-    public class PlaceExistsException extends Exception {
+    /**
-        public PlaceExistsException() {
+     * Custom Exception thrown when a Place does not exist
-            super();
+     */
-        }
+    public static class PlaceNotExistsException extends Exception {
-
-        public PlaceExistsException(String errorMessage) {
-            super(errorMessage);
-        }
-
-    }
-
-    public class PlaceNotExistsException extends Exception {
-        public PlaceNotExistsException() {
-            super();
-        }
-
         public PlaceNotExistsException(String errorMessage) {
             super(errorMessage);
         }
 
     }
 
+    /**
+     * Custom Exception thrown when the number of participants is not valid
+     */
+    public static class NumberOfParticipantInvalidException extends Exception {
+        public NumberOfParticipantInvalidException(String msg) {
+            super(msg);
+        }
+    }
 
 }

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

@@ -1,129 +1,263 @@
 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;
     private FileIO fileIO;
     private List<IsObserver> listener = new ArrayList<>();
+    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(){
-        try {
+        logger.fine("Saving Tournament to File.");
-            fileIO.saveTournament(tournament);
+        executorService.execute(new saveTask());
-        } catch (IOException e) {
+        factoryDecorator.clearMessage(false);
-            e.printStackTrace(); //TODO handle and logging
+        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){
-        if(fileIO.tournamentExists(name)){
-            System.out.println("Tournament with same name exists already.");
-            return; //TODO handle and logging
-        }
         try {
+            if(fileIO.tournamentExists(name)){
+                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 handle and logging
+            e.printStackTrace();
+            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 handle and logging
+            e.printStackTrace();
+            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 handle and logging
+            e.printStackTrace();
+            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);
+            factoryDecorator.clearMessage(true);
             informListener();
         } catch (IOException e) {
             e.printStackTrace();  //TODO handle and logging
+            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() {
+        logger.fine("Creating new Game Schedule");
+        try {
+            tournament.createGameSchedule();
+            factoryDecorator.clearMessage(true);
+        } catch (Tournament.NumberOfParticipantInvalidException e) {
+            e.printStackTrace();
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("numberParticipant");
+            factoryDecorator.printMessageToFooter(msg, true);
+            logger.warning("Failed to create Game Schedule. The number of Participants is invalid.");
+        }
+        informListener();
+    }
+
     public void savePlayer(String firstName, String name, String phoneNumber, String dateOfBirth){
         try {
-            tournament.addParticipant(new Player(firstName, name, phoneNumber, dateOfBirth));
+            tournament.saveParticipant(new Player(firstName, name, phoneNumber, dateOfBirth));
+            factoryDecorator.clearMessage(true);
             informListener();
-        } catch (Tournament.ParticipantExistsException e) {
-            e.printStackTrace(); //TODO handle and logging
         } catch (InvalidNameException e) {
             e.printStackTrace(); //TODO handle and logging
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidName");
+            factoryDecorator.printMessageToFooter(msg, true);
         } catch (Person.InvalidPhoneNumberException e) {
             e.printStackTrace(); //TODO handle and logging
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidPhone");
+            factoryDecorator.printMessageToFooter(msg, true);
+        } catch (Player.InvalidDateException e) {
+            e.printStackTrace();
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidDate");
+            factoryDecorator.printMessageToFooter(msg, true);
         }
     }
 
     public void deleteParticipant(Participant participant){
         try {
             tournament.removeParticipant(participant);
+            factoryDecorator.clearMessage(true);
             informListener();
         } catch (Tournament.ParticipantNotExistsException e) {
             e.printStackTrace(); //TODO handle and logging
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("participantNotExist");
+            factoryDecorator.printMessageToFooter(msg, true);
         }
     }
 
     public void savePlace(String name){
         try {
-            tournament.addPlace(new Place(name));
+            tournament.savePlace(new Place(name));
+            factoryDecorator.clearMessage(true);
             informListener();
-        } catch (Tournament.PlaceExistsException e) {
-            e.printStackTrace(); //TODO handle and logging
         } catch (InvalidNameException e) {
             e.printStackTrace(); //TODO handle and logging
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("invalidName");
+            factoryDecorator.printMessageToFooter(msg, true);
         }
     }
 
     public void deletePlace(Place place){
         try {
             tournament.removePlace(place);
+            factoryDecorator.clearMessage(true);
             informListener();
         } catch (Tournament.PlaceNotExistsException e) {
             e.printStackTrace(); //TODO handle and logging
+            String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("placeNotExist");
+            factoryDecorator.printMessageToFooter(msg, true);
         }
     }
 
+
     public void informListener() {
         for(IsObserver observer : listener) {
             observer.update();
         }
     }
+
+    public void closeApplication() throws InterruptedException {
+        executorService.shutdown();
+        executorService.awaitTermination(2000, TimeUnit.MILLISECONDS);
+    }
+
+
+    private class saveTask implements Runnable {
+
+        @Override
+        public void run() {
+            try {
+                fileIO.saveTournament(tournament);
+            } catch (IOException e) {
+                e.printStackTrace();
+                Platform.runLater(() -> {
+                    String msg = factoryDecorator.getLanguageConfigurator().getSelectedLanguage("IOException");
+                    factoryDecorator.printMessageToFooter(msg, true);
+                });
+            }
+        }
+    }
+
 }

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

@@ -1,40 +1,62 @@
 package ch.zhaw.projekt2.turnierverwaltung.main;
 
-import ch.zhaw.projekt2.turnierverwaltung.Factory;
+import ch.zhaw.projekt2.turnierverwaltung.*;
-import ch.zhaw.projekt2.turnierverwaltung.FactoryDecorator;
-import ch.zhaw.projekt2.turnierverwaltung.FileIO;
-import ch.zhaw.projekt2.turnierverwaltung.TournamentDecorator;
 import javafx.application.Application;
-import javafx.fxml.FXMLLoader;
 import javafx.scene.Scene;
 import javafx.scene.layout.BorderPane;
-import javafx.scene.layout.Pane;
 import javafx.stage.Stage;
 
-import java.awt.*;
+import java.util.logging.Logger;
-import java.io.IOException;
 
+/**
+ * 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") +
-    private TournamentDecorator tournamentDecorator = new TournamentDecorator(fileIO);
+            System.getProperty("file.separator") + "tournierverwaltung_angrynerds");
-    private Factory factory = new Factory(fileIO, tournamentDecorator); //TODO make it private!
     private FactoryDecorator factoryDecorator;
+    private TournamentDecorator tournamentDecorator = new TournamentDecorator(fileIO);
+    private LanguageConfigurator languageConfigurator = new LanguageConfigurator();
+    private Factory factory = new Factory(fileIO, tournamentDecorator, languageConfigurator);
+    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
 
+    /**
+     * Start method used to initialize the main window and load it's needed component
+     * Also sets the scene and set some values like min width and height
+     *
+     * @param primaryStage to be displayed
+     */
     @Override
-    public void start(Stage primaryStage) throws Exception {
+    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.loadTournamentList(pane, factoryDecorator);
+        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(false);
+        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");
+        }
+    }
 }

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() {
-
     }
 }

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;
+    }
+}

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

@@ -1,16 +1,94 @@
 package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
 
-import ch.zhaw.projekt2.turnierverwaltung.FXController;
+import ch.zhaw.projekt2.turnierverwaltung.*;
+import javafx.beans.value.ObservableValue;
+import javafx.event.Event;
 import javafx.fxml.FXML;
 import javafx.scene.control.ChoiceBox;
+import javafx.scene.control.Label;
+import javafx.scene.control.TextField;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.VBox;
 
-public class GameController extends FXController {
+/**
+ * Class GameController in Charge of the Controller Element of the Schedule view.
+ */
+public class GameController extends FXController{
+
+    private GameDecorator gameDecorator;
 
     @FXML
-    private ChoiceBox<?> placesChoiceBox;
+    private VBox mainVBox;
+
+    @FXML
+    private Label participantNameOne;
+
+    @FXML
+    private Label participantNameTwo;
+
+    @FXML
+    private ChoiceBox<Place> placesChoiceBox;
+
+    @FXML
+    private TextField pointsTeamOne;
+
+    @FXML
+    private TextField pointsTeamTwo;
+
+    @FXML
+
+    private Label locationLabel;
+
+    @Override
+    public void shareGUIElementWithLanguageConfigurator() {
+        getLanguageConfigurator().recieveLabel(locationLabel);
+    }
+
+    @FXML
+    void saveGameResult() {
+        gameDecorator.saveGameResult(pointsTeamOne.getText(), pointsTeamTwo.getText());
+    }
+
+
+    private void saveGamePlace(Place newPlace) {
+        gameDecorator.saveGamePlace(newPlace);
+    }
+
+    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()));
+        pointsTeamTwo.setText(String.valueOf(gameDecorator.getPoints2()));
+        placesChoiceBox.setItems(getTournamentDecorator().getTournament().getPlaces());
+        placesChoiceBox.setValue(gameDecorator.getPlace());
     }
-}
+
+    public void refreshParticipants(){
+        gameDecorator.refreshParticipants();
+    }
+
+    public void addListener(GameDecorator gameDecorator){
+        gameDecorator.addListener(new IsObserver() {
+            @Override
+            public void update() {
+                refreshParticipants();
+                loadContent();
+            }
+        });
+    }
+
+
+    public void setup(TournamentDecorator tournamentDecorator, FileIO fileIO, FactoryDecorator factoryDecorator, Pane pane, GameDecorator gameDecorator,LanguageConfigurator languageConfigurator) {
+        setTournamentDecorator(tournamentDecorator);
+        this.gameDecorator = gameDecorator;
+        setup(languageConfigurator);
+        placesChoiceBox.getSelectionModel().selectedItemProperty().addListener((ObservableValue<? extends Place> observable, Place oldValue, Place newValue) -> saveGamePlace(newValue == null ? oldValue : newValue));
+    }
+
+}

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

@@ -0,0 +1,134 @@
+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));
+        } else {
+            game.setPoints1(0);
+        }
+        if(points2.length() > 0) {
+            game.setPoints2(Integer.parseInt(points2));
+        } else {
+            game.setPoints2(0);
+        }
+        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();
+        }
+        return "1";
+    }
+
+    /**
+     *
+     * @return returns Gameparticipant two
+     */
+    public String getParticipantTwo() {
+        if (game.getParticipant2() != null) {
+            return game.getParticipant2().toString();
+        }
+        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();
+        }
+    }
+}

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

@@ -3,22 +3,75 @@ package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
 import ch.zhaw.projekt2.turnierverwaltung.FXController;
 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 {
+    
+    @FXML
+    private Button createScheduleBtn;
+
+    @FXML
+    private Button editLocBtn;
+
+    @FXML
+    private Button editParticipantBtn;
+
+    @FXML
+    private Button closeTournamentBtn;
+
+    @FXML
+    private HBox hBoxCenter;
+
+    @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) {
-        getFactoryDecorator().openPlacesFormular();
+        getFactoryDecorator().openPlacesForm();
     }
 
     @FXML
     void openParticipantFormular(ActionEvent event) {
-        getFactoryDecorator().openParticipantFormular();
+        getFactoryDecorator().openParticipantForm();
+    }
+
+    @FXML
+    void closeTournament(ActionEvent event) {
+        getFactoryDecorator().openTournamentList();
+    }
+
+    @FXML
+    void changeView(ActionEvent event) {
+        loadContent();
     }
 
     @Override
     public void loadContent() {
-
+        getFactoryDecorator().loadGameList(hBoxCenter, getTournamentDecorator(), treeView.isSelected());
     }
 }
 

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,33 +73,85 @@ 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();
+        phoneNumberTextField.clear();
+        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) {
+    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();
+        }
     }
 }

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

@@ -2,42 +2,24 @@ package ch.zhaw.projekt2.turnierverwaltung.main.placesAddFormular;
 
 import ch.zhaw.projekt2.turnierverwaltung.FXController;
 import ch.zhaw.projekt2.turnierverwaltung.Place;
-import ch.zhaw.projekt2.turnierverwaltung.Player;
+import ch.zhaw.projekt2.turnierverwaltung.Tournament;
-import javafx.event.ActionEvent;
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
 import javafx.scene.control.Label;
 import javafx.scene.control.ListView;
 import javafx.scene.control.TextField;
-import javafx.scene.input.MouseEvent;
 import javafx.scene.layout.GridPane;
 import javafx.scene.layout.VBox;
 
+import javafx.scene.input.MouseEvent;
+
+import java.util.logging.Logger;
+
+/**
+ * Controller of the places form, in charge of its functionality.
+ */
 public class PlacesFormularController extends FXController {
 
-    @FXML
-    private Button addBtn;
-
-    @FXML
-    private Label birthDateLabel;
-
-    @FXML
-    private TextField birthDateTextField;
-
-    @FXML
-    private VBox changeBtn;
-
-    @FXML
-    private Label firstNameLabel;
-
-    @FXML
-    private TextField firstNameTextField;
-
-    @FXML
-    private GridPane grid;
-
-    @FXML
-    private Label newPlaceFormularTitle;
 
     @FXML
     private Button closeBtn;
@@ -45,6 +27,8 @@ public class PlacesFormularController extends FXController {
     @FXML
     private Button deleteBtn;
 
+    @FXML
+    private Label newPlaceTitle;
 
     @FXML
     private Label placeListTitle;
@@ -58,39 +42,82 @@ public class PlacesFormularController extends FXController {
     @FXML
     private TextField placeNameTextField;
 
-    @FXML
-    private Label phoneNumberLabel;
-
-    @FXML
-    private TextField phoneNumberTextField;
-
     @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());
+        logger.fine("Saved " + placeNameTextField + " to the list of places");
+        clearForm();
     }
 
+    /**
+     * Method clears the input field
+     */
+    private void clearForm() {
+        logger.finer("Clearing input text field");
+        placeNameTextField.clear();
+    }
+
+    /**
+     * Method deletes the currently selected place from the list.
+     */
     @FXML
-    void delete(ActionEvent event) {
+    void delete() {
         Place place = placeListView.getSelectionModel().getSelectedItems().get(0);
+        logger.fine("Deleting " + place + "from place list");
         getTournamentDecorator().deletePlace(place);
     }
 
+    /**
+     * Closes the current Place view, going back to previous view
+     */
     @FXML
-    void close(ActionEvent event) {
+    void close() {
+        logger.fine("Closing place form");
         getFactoryDecorator().openScheduleView();
     }
 
+    /**
+     * Loads the already saved places and displays them on the places list.
+     */
     @Override
     public void loadContent() {
-        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();
+        }
     }
 }

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

@@ -1,31 +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;
 
-import java.io.IOException;
-
 public class AlertDelete extends Alert {
-    ButtonType yesButton = new ButtonType("Ja", ButtonBar.ButtonData.YES);
+    ButtonType yesButton;
-    ButtonType noButton = new ButtonType("Nein", ButtonBar.ButtonData.NO);
+    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");
+        yes = languageConfigurator.getSelectedLanguage("yes");
-        setHeaderText("Turnier entfernen?");
+        no = languageConfigurator.getSelectedLanguage("no");
-        setContentText("Sind Sie sicher, dass sie das Turnier " + name + " entfernen wollen?\n" +
+        titleDelete = languageConfigurator.getSelectedLanguage("titleDelete");
-                "Nach diesem Vorgang kann es nicht wiederhergestellt werden.");
+        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 = type == yesButton;
-                result = true;
-            }
         });
         return result;
     }

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

@@ -2,6 +2,7 @@ package ch.zhaw.projekt2.turnierverwaltung.main.tournamentList;
 
 import ch.zhaw.projekt2.turnierverwaltung.FXController;
 import ch.zhaw.projekt2.turnierverwaltung.FileIO;
+import ch.zhaw.projekt2.turnierverwaltung.InvalidNameException;
 import ch.zhaw.projekt2.turnierverwaltung.Tournament;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
@@ -24,8 +25,6 @@ public class TournamentListController extends FXController {
     @FXML
     private Button createBtn;
 
-    @FXML
-    private GridPane grid;
 
     @FXML
     private ChoiceBox<Tournament.Type> modusChoiceBox;
@@ -54,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());
@@ -68,7 +78,7 @@ public class TournamentListController extends FXController {
     @FXML
     void deleteTournament(ActionEvent event) {
         FileIO.TournamentFile tournamentFile = tournamentListView.getSelectionModel().getSelectedItems().get(0);
-        AlertDelete alert = new AlertDelete(tournamentFile.toString());
+        AlertDelete alert = new AlertDelete(getLanguageConfigurator());
         if(alert.showAndGetResult()){
            getTournamentDecorator().deleteTournament(tournamentFile);
         }

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

@@ -8,7 +8,7 @@
 <?import javafx.scene.layout.VBox?>
 <?import javafx.scene.text.Font?>
 
-<BorderPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.MainWindowController">
+<BorderPane maxHeight="-Infinity" maxWidth="-Infinity" 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.MainWindowController">
    <top>
       <VBox alignment="TOP_CENTER" prefHeight="86.0" prefWidth="600.0" BorderPane.alignment="CENTER">
          <children>
@@ -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>
@@ -34,4 +35,12 @@
          </children>
       </VBox>
    </top>
+   <bottom>
+      <VBox prefHeight="49.0" prefWidth="600.0" BorderPane.alignment="CENTER">
+         <children>
+            <VBox alignment="CENTER" prefHeight="200.0" prefWidth="100.0" />
+            <VBox alignment="CENTER_RIGHT" prefHeight="200.0" prefWidth="100.0" />
+         </children>
+      </VBox>
+   </bottom>
 </BorderPane>

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

@@ -7,40 +7,53 @@
 <?import javafx.scene.layout.HBox?>
 <?import javafx.scene.layout.VBox?>
 
-
+<VBox alignment="CENTER" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="90.0" prefWidth="450.0" style="-fx-border-color: black; -fx-border-insets: 2; -fx-border-width: 3;" xmlns="http://javafx.com/javafx/18" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView.GameController">
-<VBox alignment="CENTER" maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="150.0" prefWidth="200.0" xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1" fx:controller="GameContoller">
    <children>
-      <Label fx:id="teamNameOne" text="Team One" />
+      <VBox fx:id="mainVBox" alignment="CENTER" maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" prefHeight="90.0">
-      <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0">
          <children>
-            <Label text="Points">
+            <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0">
-               <HBox.margin>
+               <children>
-                  <Insets right="20.0" />
+                  <Label fx:id="participantNameOne" style="-fx-font-weight: bold;" text="Participant One">
-               </HBox.margin>
+                     <HBox.margin>
-            </Label>
+                        <Insets right="20.0" />
-            <TextField fx:id="pointsTeamOne" prefHeight="25.0" prefWidth="50.0" />
+                     </HBox.margin>
+                  </Label>
+                  <TextField fx:id="pointsTeamOne" alignment="CENTER" onKeyTyped="#saveGameResult" prefHeight="25.0" prefWidth="50.0">
+                     <HBox.margin>
+                        <Insets right="20.0" />
+                     </HBox.margin>
+                  </TextField>
+                  <Label text=":">
+                     <HBox.margin>
+                        <Insets right="20.0" />
+                     </HBox.margin>
+                  </Label>
+                  <TextField fx:id="pointsTeamTwo" alignment="CENTER" onKeyTyped="#saveGameResult" prefHeight="25.0" prefWidth="50.0">
+                     <HBox.margin>
+                        <Insets right="20.0" />
+                     </HBox.margin>
+                  </TextField>
+                  <Label fx:id="participantNameTwo" style="-fx-font-weight: bold;" text="Participant Two">
+                     <HBox.margin>
+                        <Insets right="20.0" />
+                     </HBox.margin>
+                  </Label>
+               </children>
+            </HBox>
+            <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0">
+               <children>
+                  <Label fx:id="locationLabel" text="Ort">
+                     <HBox.margin>
+                        <Insets right="20.0" />
+                     </HBox.margin>
+                  </Label>
+                  <ChoiceBox fx:id="placesChoiceBox" prefWidth="150.0" />
+               </children>
+               <VBox.margin>
+                  <Insets top="10.0" />
+               </VBox.margin>
+            </HBox>
          </children>
-      </HBox>
+      </VBox>
-      <Label fx:id="teamNameTwo" text="Team Two" />
-      <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0">
-         <children>
-            <Label text="Points">
-               <HBox.margin>
-                  <Insets right="20.0" />
-               </HBox.margin>
-            </Label>
-            <TextField fx:id="pointsTeamTwo" prefHeight="25.0" prefWidth="50.0" />
-         </children>
-      </HBox>
-      <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0">
-         <children>
-            <Label text="Ort">
-               <HBox.margin>
-                  <Insets right="20.0" />
-               </HBox.margin>
-            </Label>
-            <ChoiceBox fx:id="placesChoiceBox" prefWidth="150.0" />
-         </children>
-      </HBox>
    </children>
 </VBox>

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

@@ -2,22 +2,45 @@
 
 <?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/18" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView.GameScheduleController">
-<BorderPane maxHeight="-Infinity" maxWidth="-Infinity" minHeight="-Infinity" minWidth="-Infinity" prefHeight="400.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/17" 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="CENTER_RIGHT" prefHeight="100.0" prefWidth="200.0" BorderPane.alignment="CENTER">
+      <HBox alignment="CENTER_LEFT" prefHeight="100.0" prefWidth="200.0" BorderPane.alignment="CENTER">
          <children>
-            <Button mnemonicParsing="false" onAction="#openParticipantFormular" text="Teilnehmer bearbeiten">
+            <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>
             </Button>
-            <Button mnemonicParsing="false" onAction="#openPlacesFormular" text="Orte bearbeiten">
+            <Button fx:id="editParticipantBtn" mnemonicParsing="false" onAction="#openParticipantFormular" text="Teilnehmer bearbeiten">
                <HBox.margin>
-                  <Insets right="40.0" />
+                  <Insets right="20.0" />
+               </HBox.margin>
+            </Button>
+            <Button fx:id="editLocBtn" mnemonicParsing="false" onAction="#openPlacesFormular" text="Orte bearbeiten">
+               <HBox.margin>
+                  <Insets right="20.0" />
+               </HBox.margin>
+            </Button>
+            <Button fx:id="closeTournamentBtn" mnemonicParsing="false" onAction="#closeTournament" text="Close Tournament">
+               <HBox.margin>
+                  <Insets right="20.0" />
                </HBox.margin>
             </Button>
          </children>

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

@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
+
 <?import javafx.geometry.Insets?>
 <?import javafx.scene.control.Button?>
 <?import javafx.scene.control.Label?>
@@ -12,7 +13,7 @@
 <?import javafx.scene.layout.VBox?>
 <?import javafx.scene.text.Font?>
 
-<HBox alignment="CENTER" VBox.vgrow="ALWAYS" xmlns:fx="http://javafx.com/fxml/1" xmlns="http://javafx.com/javafx/17" 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>
@@ -55,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="Teilnehmer ändern/erstellen">
+            <Label fx:id="newPlaceTitle" text="Ort ändern/erstellen">
                <font>
                   <Font name="System Bold" size="21.0" />
                </font>
@@ -86,16 +87,6 @@
                         <Insets />
                      </GridPane.margin>
                   </TextField>
-                  <Label fx:id="firstNameLabel" styleClass="lableGrid" text="Vorname" GridPane.rowIndex="1">
-                     <GridPane.margin>
-                        <Insets />
-                     </GridPane.margin>
-                  </Label>
-                  <TextField fx:id="firstNameTextField" GridPane.columnIndex="1" GridPane.rowIndex="1" />
-                  <TextField fx:id="phoneNumberTextField" GridPane.columnIndex="1" GridPane.rowIndex="2" />
-                  <TextField fx:id="birthDateTextField" GridPane.columnIndex="1" GridPane.rowIndex="3" />
-                  <Label fx:id="phoneNumberLabel" text="Telefonnummer" GridPane.rowIndex="2" />
-                  <Label fx:id="birthDateLabel" text="Geb. Datum" GridPane.rowIndex="3" />
                </children>
             </GridPane>
             <Separator prefWidth="200.0" />

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();
+        }
+    }
+}

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

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());
+
+    }
+}

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"));
+
+    }
+}

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();
+        }
+    }
+
+}

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();
+        }
+    }
+}

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();
+        }
+    }
+}

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")));
+    }
+}

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

@@ -0,0 +1,153 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+@DisplayName("TournamentTest")
+public class TournamentTest {
+
+    @Nested
+    @DisplayName("KOMode")
+    public class KOMode {
+        private Tournament tournament;
+
+        @BeforeEach
+        void setup() {
+            try {
+                tournament = new Tournament("Name", Tournament.Type.KO);
+            } catch (InvalidNameException e) {
+                e.printStackTrace();
+                fail();
+            } catch (Tournament.InvalidTypeException e) {
+                e.printStackTrace();
+                fail();
+            }
+        }
+
+        @Test
+        @DisplayName("Test invalid instance")
+        void makeInvalidInstance() {
+            assertThrows(InvalidNameException.class, () -> new Tournament(".", Tournament.Type.KO));
+        }
+
+        @Test
+        @DisplayName("Save Participant")
+        void saveParticipantTest() {
+            //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();
+            }
+
+        }
+
+        @Test
+        @DisplayName("Remove Participant")
+        void removeParticipantTest() {
+            Participant participant = Mockito.mock(Player.class);
+
+            //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());
+                tournament.removeParticipant(participant);
+                assertEquals(0, tournament.getParticipants().size());
+            } catch (Tournament.ParticipantNotExistsException | Person.InvalidPhoneNumberException e) {
+                fail();
+            }
+        }
+
+        @Test
+        @DisplayName("Add Place")
+        void addPlaceTest() {
+            Place place = mock(Place.class);
+            when(place.equals(any(Place.class))).thenReturn(false).thenReturn(true);
+
+            assertEquals(0, tournament.getPlaces().size());
+            tournament.savePlace(place);
+            assertEquals(1, tournament.getPlaces().size());
+            tournament.savePlace(place);
+            assertEquals(2, tournament.getPlaces().size());
+            tournament.savePlace(place);
+            assertEquals(2, tournament.getPlaces().size());
+        }
+
+        @Test
+        @DisplayName("Remove Place")
+        void removePlaceTest() {
+            Place place = mock(Place.class);
+
+            assertThrows(Tournament.PlaceNotExistsException.class, () -> tournament.removePlace(place));
+
+            tournament.savePlace(place);
+            assertEquals(1, tournament.getPlaces().size());
+            try {
+                tournament.removePlace(place);
+                assertEquals(0, tournament.getPlaces().size());
+            } catch (Tournament.PlaceNotExistsException e) {
+                fail();
+            }
+        }
+
+        @Test
+        @DisplayName("Test gameschedule calculation")
+        void calcGameSchedule() {
+            Participant participant = mock(Player.class);
+            when(participant.equals(any(Participant.class))).thenReturn(false);
+
+            //Checks if invalid number of Participants throws error
+            assertThrows(Tournament.NumberOfParticipantInvalidException.class, () -> tournament.createGameSchedule());
+            for (int i = 0; i < 8; i++) {
+                if (i % 4 == 0 && i > 0) {
+                    try {
+                        tournament.createGameSchedule();
+                        assertEquals(2, tournament.getGameList().size());
+                        tournament.saveParticipant(participant);
+                    } 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 {
+                tournament.createGameSchedule();
+            } catch (Tournament.NumberOfParticipantInvalidException e) {
+                fail();
+            }
+            assertEquals(3, tournament.getGameList().size());
+        }
+
+    }
+}