removed "äöü" from error messages.

changed error Message numberOfParticipants.
2022-05-13 17:51:04 +02:00 · 2022-05-13 17:10:32 +02:00 · 2022-05-13 16:51:17 +02:00 · 2022-05-13 16:50:35 +02:00 · 2022-05-13 16:12:29 +02:00 · 2022-05-13 16:12:06 +02:00
42 changed files with 2320 additions and 324 deletions
@@ -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()
+
+
 }
@@ -6,8 +6,18 @@ package ch.zhaw.projekt2.turnierverwaltung;
 import ch.zhaw.projekt2.turnierverwaltung.main.MainWindow;
 import javafx.application.Application;

+import java.io.IOException;
+
 public class App {
    public static void main(String[] args) {
+        try {
+            new LogConfiguration(System.getProperty("user.dir") + System.getProperty("file.separator") + "tournierverwaltung_angrynerds",
+                    "ch" + System.getProperty("file.separator") + "zhaw" + System.getProperty("file.separator") + "projekt2" + System.getProperty("file.separator") +
+                    "turnierverwaltung" + System.getProperty("file.separator") + "logging" + System.getProperty("file.separator") + "log.properties");
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
        Application.launch(MainWindow.class,args);
    }
 }
@@ -3,30 +3,62 @@ package ch.zhaw.projekt2.turnierverwaltung;
 import javafx.scene.layout.Pane;

 public abstract class FXController {
-    Tournament tournament;
-    Factory factory;
+    TournamentDecorator tournamentDecorator;
+    FactoryDecorator factoryDecorator;
    FileIO fileIO;
    Pane pane;
+    IsObserver listener;

-    public void setup(Tournament tournament, FileIO fileIO, Factory factory, Pane pane){
-        this.tournament = tournament;
+    public FXController(){
+        listener = new IsObserver() {
+            @Override
+            public void update() {
+                loadContent();
+            }
+        };
+    }
+
+    public void setup(TournamentDecorator tournamentDecorator, FileIO fileIO, FactoryDecorator factoryDecorator, Pane pane){
+        this.tournamentDecorator = tournamentDecorator;
        this.fileIO = fileIO;
-        this.factory = factory;
+        this.factoryDecorator = factoryDecorator;
        this.pane = pane;
+        addListener();
    }

    public abstract void loadContent();

-    protected Tournament getTournament() {
-        return tournament;
+    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 Factory getFactory() {
-        return factory;
+    protected void setPane(Pane pane) {
+        this.pane = pane;
    }

    protected Pane getPane() {
@@ -1,29 +1,35 @@
 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;

 public class Factory {
-    private Tournament tournament;
+    private TournamentDecorator tournamentDecorator;
    private FileIO fileIO;

-    public Factory(FileIO fileIO){
+    public Factory(FileIO fileIO, TournamentDecorator tournamentDecorator) {
        this.fileIO = fileIO;
+        this.tournamentDecorator = tournamentDecorator;
+
    }

-    public Tournament getTournament() {
-        return tournament;
+    public TournamentDecorator getTournamentDecorator() {
+        return tournamentDecorator;
    }

    public void setTournament(Tournament tournament) {
-        this.tournament = tournament;
+        this.tournamentDecorator.setTournament(tournament);
    }

-    public BorderPane loadMainWindow(){
+    public BorderPane loadMainWindow() {
        FXMLLoader loader = new FXMLLoader(getClass().getResource("mainWindow.fxml"));
        try {
            return loader.load();
@@ -34,32 +40,120 @@ public class Factory {
        return null;
    }

-    public void loadTournamentList(BorderPane pane){
-        TournamentListController controller = (TournamentListController) setCenterOfBorderPane(pane, getClass().getResource("tournamentList/tournamentList.fxml"));
+    public void loadAllViews(FactoryDecorator factoryDecorator, BorderPane pane){
+        for(View view : View.values()){
+            try {
+                view.loadView(tournamentDecorator, fileIO, factoryDecorator, pane);
+            } catch (IOException e) {
+                e.printStackTrace();
+                //TODO Handle and logging.
+            }
+        }
+    }
+
+    public void showTournamentList(BorderPane pane, FactoryDecorator factoryDecorator) {
+        tournamentDecorator.setTournament(null);
+        setCenterOfBorderPane(pane, View.tournamentList);
    }

    //Can be used to Open new Scene in same Stage.
    //This way possible to later give object to Controller
-    public void loadParticipantFormular(BorderPane pane) {
-        setCenterOfBorderPane(pane, getClass().getResource("participantAddFormular/participantFormular.fxml"));
+    public void showParticipantFormular(BorderPane pane, FactoryDecorator factoryDecorator) {
+        setCenterOfBorderPane(pane, View.participantFormular);
    }

-    private FXController setCenterOfBorderPane(BorderPane pane, URL location) {
+    public void showPlacesFormular(BorderPane pane, FactoryDecorator factoryDecorator) {
+        setCenterOfBorderPane(pane, View.placesFormular);
+    }
+
+    public void showGameScheduler(BorderPane pane, FactoryDecorator factoryDecorator) {
+        setCenterOfBorderPane(pane, View.gameScheduler);
+    }
+
+    private void setCenterOfBorderPane(BorderPane pane, View view) {
        FXController controller = null;
+        pane.setCenter(view.getPane());
+        resetFooter(pane, true);
+    }
+
+
+    public GameController loadGameView(VBox box, GameDecorator gameDecorator, FactoryDecorator factoryDecorator) {
        try {
-            FXMLLoader loader = new FXMLLoader(location);
-            pane.setCenter(loader.load());
-            controller = loader.getController();
-            controller.setup(tournament, fileIO, this, pane);
-            controller.loadContent();
+            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);
+            return controller;
        } catch (IOException e) {
            e.printStackTrace();
-            //TODO handle and logging?
+            //TODO LOGGER
        }
-        return controller;
+        return null;
+    }
+
+    public void printMessageToFooter(BorderPane pane, String msg, boolean error) {
+        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);
+
        }


+    }

+    public void resetFooter(BorderPane pane,boolean error) {
+        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 enum View {
+        tournamentList("tournamentList/tournamentList.fxml"),
+        participantFormular("participantAddFormular/participantFormular.fxml"),
+        placesFormular("placesAddFormular/PlacesFormular.fxml"),
+        gameScheduler("gameScheduleView/GameSchedule.fxml");
+
+        private String fxmlFileName;
+        private Pane pane;
+
+        private View(String fxmlFileName) {
+            this.fxmlFileName = fxmlFileName;
+        }
+
+        public Pane getPane() {
+            return pane;
+        }
+
+        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);
+        }
+
+    }

 }
@@ -0,0 +1,177 @@
+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;
+
+public class FactoryDecorator implements IsObservable{
+    private Factory factory;
+    private FileIO fileIO;
+    private Pane pane;
+    private List<IsObserver> listener = new ArrayList<>();
+
+    public FactoryDecorator(FileIO fileIO, Factory factory, Pane pane){
+        setFactory(factory);
+        setFileIO(fileIO);
+        setPane(pane);
+    }
+
+    public void setFileIO(FileIO fileIO) {
+        this.fileIO = fileIO;
+    }
+
+    public void setFactory(Factory factory) {
+        this.factory = factory;
+    }
+
+    public void setPane(Pane pane) {
+        this.pane = pane;
+    }
+
+    @Override
+    public void addListener(IsObserver observer) {
+        listener.add(observer);
+    }
+
+    @Override
+    public void removeListener(IsObserver observer) {
+        listener.remove(observer);
+    }
+
+    public void openTournament(FileIO.TournamentFile tournamentFile){
+        try {
+            factory.setTournament(fileIO.loadTournament(tournamentFile));
+            openScheduleView();
+            clearMessage(false);
+        } catch (IOException | ClassNotFoundException e) {
+            e.printStackTrace();
+            printMessageToFooter("Fehler beim lesen der Datei.", true);
+        }  //TODO handle and logging
+    }
+
+    public void openTournamentList() {
+        factory.showTournamentList((BorderPane) pane, this);
+        informListener();
+    }
+
+    public void openParticipantFormular() {
+        factory.showParticipantFormular((BorderPane) pane, this);
+        informListener();
+    }
+
+    public void openPlacesFormular() {
+        factory.showPlacesFormular((BorderPane) pane, this);
+        informListener();
+    }
+
+    public void openScheduleView() {
+        factory.showGameScheduler((BorderPane) pane, this);
+        informListener();
+    }
+
+    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.getGameBoxHeigth();
+                }
+                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;
+        }
+    }
+
+    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;
+    }
+
+    public GameController openGameView(VBox vBox, GameDecorator gameDecorator) {
+        return factory.loadGameView(vBox ,gameDecorator, this);
+    }
+
+    public void printMessageToFooter(String msg, boolean error) {
+        factory.printMessageToFooter((BorderPane) pane,msg,error);
+    }
+
+    public void clearMessage(boolean error){
+        factory.resetFooter((BorderPane) pane, error);
+    }
+
+    public void informListener() {
+        for(IsObserver observer : listener) {
+            observer.update();
+        }
+    }
+}
@@ -1,21 +1,27 @@
 package ch.zhaw.projekt2.turnierverwaltung;


+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
 import java.io.*;
 import java.net.URI;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
 import java.util.logging.Logger;

-
+/**
+ * Class in Charge of Reading and Writing files
+ */
 public class FileIO {
    private File mainDir;
    private File saves;

-    private static final Logger logger = Logger.getLogger(FileIO.class.getName());
-
+    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());

+    /**
+     * Constructor initiates the Directory and creates a save folder if not already existing.
+     *
+     * @param saveLocation the directory in which the save Files will be saved
+     */
    public FileIO(String saveLocation) {
        this.mainDir = new File(saveLocation);
        if (!mainDir.exists()) {
@@ -34,22 +40,48 @@ public class FileIO {
        }
    }

-    public List<TournamentFile> getList() {
+
+    /**
+     * Returns a list with all save Files that are located inside the save folder.
+     *
+     * @return List with all containing save Files
+     */
+    public ObservableList<TournamentFile> getList() {
        logger.fine("Creating a List out of all Files in the save directory and returning it");
-        List<TournamentFile> tournaments = new ArrayList<>();
-        for(File tournament : saves.listFiles()){
-            tournaments.add(new TournamentFile(tournament.toURI()));
+        ObservableList<TournamentFile> tournamentFiles = FXCollections.observableArrayList();
+        for (File tournament : saves.listFiles()) {
+            tournamentFiles.add(new TournamentFile(tournament.toURI()));
        }
-        return tournaments;
+        return tournamentFiles;
    }

    /**
-     * @param tournamentFile
-     * @return
-     * @throws ClassNotFoundException
-     * @throws IOException            File not found or not readable.
+     * 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 Tournament loadTournament(File tournamentFile) throws IOException, ClassNotFoundException {
+    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())) {
+                logger.fine(name + " is an already existing name in the list");
+                return true;
+            }
+        }
+        logger.fine(name + " is an unique name in the list");
+        return false;
+    }
+
+    /**
+     * Loads and returns a tournament from a given File which contains the serialiazed 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
+     * @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 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");
@@ -64,52 +96,64 @@ public class FileIO {
            logger.finer("Starting to read tournament File");
            tournament = (Tournament) in.readObject();
        } catch (FileNotFoundException e) {
-            logger.severe("Could not find tournament File");
+            logger.severe("Could not find tournament File" + e);
            throw e;
        } catch (IOException e) {
            logger.severe("Failed to read File" + tournamentFile.getName());
-            throw new IOException("Error while reading File",e);
+            throw new IOException("Error while reading File", e);
        } catch (ClassNotFoundException e) {
-            logger.severe("No definition for the class with the specified name could be found");
-            throw new ClassNotFoundException("No definition for the class with the specified name could be found",e);
+            logger.severe("No definition for the class with the specified name could be found" + e);
+            throw new ClassNotFoundException("No definition for the class with the specified name could be found", e);
        } finally {
            if (in != null) {
                try {
                    logger.finer("Trying to close input stream");
                    in.close();
                } catch (IOException e) {
-                    logger.severe("Failed to close input stream");
-                    throw new IOException("Error while closing input stream",e);
+                    logger.severe("Failed to close input stream" + e);
+                    throw new IOException("Error while closing input stream", e);
                }
            }
        }
        return tournament;
    }

-    public void saveTournament(Tournament tournament) {
+    /**
+     * Serializables 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 synchronized void saveTournament(Tournament tournament) throws IOException, FileNotFoundException {
        if (tournament == null) {
            logger.warning("Given tournament file is empty");
            throw new IllegalArgumentException("Null tournament received");
        }
+        logger.fine("Creates the Object for the path of the save file");
        File newSave = new File(saves, tournament.getName() + ".txt");
        ObjectOutputStream out = null;

        try {
+            logger.fine("creates or overwrites the new save FILE");
            newSave.createNewFile();
            out = new ObjectOutputStream(new FileOutputStream(newSave));
            out.writeObject(tournament);
-            System.out.println("Save File" + tournament.getName() + ".txt being saved to " + saves.getAbsolutePath());
+            System.out.println("Save File " + tournament.getName() + ".txt being saved to " + saves.getAbsolutePath());

        } catch (FileNotFoundException e) {
-            throw new RuntimeException(e);
+            logger.severe("Could not find tournament File" + e);
+            throw e;
        } catch (IOException e) {
-            throw new RuntimeException(e);
+            logger.severe("Failed to write File " + tournament.getName() + e);
+            throw new IOException("Error while writing File", e);
        } finally {
            if (out != null) {
                try {
                    out.close();
                } catch (IOException e) {
-                    throw new RuntimeException(e);
+                    logger.severe("Failed to close output stream" + e);
+                    throw new IOException("Error while closing output stream", e);
                }
            }

@@ -117,16 +161,49 @@ public class FileIO {

    }

-    public class TournamentFile extends File{
+    /**
+     * Deletes the requested File in the directory
+     *
+     * @param tournamentFile the file that should be deleted
+     * @throws FileNotFoundException    File could not be deleted
+     * @throws IllegalArgumentException File is null
+     */
+    public void deleteTournament(File tournamentFile) throws FileNotFoundException {
+        if (tournamentFile == null) {
+            throw new IllegalArgumentException("Receiving file is null");
+        }
+        if (tournamentFile.delete()) {
+            logger.fine("deleted requested File");
+        } else {
+            logger.warning("Failed to delete requested File");
+            throw new FileNotFoundException("File deletion unsuccessful");
+        }
+    }

+    /**
+     * TournamentFile Class is in use to add missing functionality that is
+     */
+    public 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.
+         */
        public TournamentFile(URI uri) {
            super(uri);
        }

-        public String toString(){
-            String name = getName();
-            return name.split("\\.")[0];
+        /**
+         * Method overrides toString to return the names of the tournaments without having .txt endings.
+         *
+         * @return String without a txt ending
+         */
+        @Override
+        public String toString() {
+            return getName().split("\\.")[0];
        }

    }
+
 }
@@ -1,16 +1,22 @@
 package ch.zhaw.projekt2.turnierverwaltung;

-public class Game {
-    private Participant participant1, Participant2;
-    private int points1, points2;
-    private Location location;
+import java.io.Serializable;

-    public Location getLocation() {
-        return location;
+public class Game implements Serializable {
+    private Participant participant1, participant2;
+    private int points1, points2;
+    private Place place;
+    private Game previousGame1, previousGame2;
+
+
+    public Game(Participant participant1, Participant participant2) {
+        this.participant1 = participant1;
+        this.participant2 = participant2;
    }

-    public void setLocation(Location location) {
-        this.location = location;
+    public Game(Game previousGame1, Game previousGame2){
+        this.previousGame1 = previousGame1;
+        this.previousGame2 = previousGame2;
    }

    public int getPoints1() {
@@ -37,11 +43,35 @@ public class Game {
        this.participant1 = participant1;
    }

-    public Participant getParticipant2() {
-        return Participant2;
+    public void setParticipant2(Participant participant2) {
+        this.participant2 = participant2;
    }

-    public void setParticipant2(Participant participant2) {
-        Participant2 = participant2;
+    public Participant getParticipant2() {
+        return participant2;
    }
+
+    public void setPlace(Place place) {
+        this.place = place;
+    }
+
+    public Place getPlace() {
+        return place;
+    }
+
+    public Participant getWinner(){
+        if(points1 > points2){
+            return participant1;
+        } else if(points2 > points1){
+            return participant2;
+        } else {
+            return null;
+        }
+    }
+
+    public void refreshParticipants(){
+        participant1 = previousGame1.getWinner();
+        participant2 = previousGame2.getWinner();
+    }
+
 }
@@ -0,0 +1,12 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+public class InvalidNameException extends Exception {
+    public InvalidNameException() {
+        super();
+    }
+
+    public InvalidNameException(String errorMessage) {
+        super(errorMessage);
+    }
+
+}
@@ -0,0 +1,19 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+/**
+ * Most basic interface for observing an object
+ * @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);
+}
@@ -0,0 +1,14 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+/**
+ * Most basic interface for beeing an observer
+ * @author bles
+ *
+ */
+public interface IsObserver {
+    /**
+     * This method is always called when an observed object
+     * changes
+     */
+    void update();
+}
@@ -1,17 +0,0 @@
-package ch.zhaw.projekt2.turnierverwaltung;
-
-public class Location {
-    private String name;
-
-    public Location(String name){
-        setName(name);
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
-}
@@ -0,0 +1,41 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.logging.*;
+
+
+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 {
+        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);
+            mainDir.mkdir();
+        } else {
+            logger.finer("main directory for log folder already exists");
+        }
+
+        File saves = new File(mainDir, "log_files");
+        if (!saves.exists()) {
+            saves.mkdir();
+            logger.fine("Creating log save directory");
+        } else {
+            logger.finer("log save directory already exists");
+        }
+
+        String propertiesPath = "ch" + System.getProperty("file.separator") + "zhaw" + System.getProperty("file.separator") + "projekt2" + System.getProperty("file.separator") +
+                "turnierverwaltung" + System.getProperty("file.separator") + "logging" + System.getProperty("file.separator") + "log.properties";
+
+        logger.fine("Getting and reading logconfig file from " + propertiesPath);
+        InputStream logConfig = this.getClass().getClassLoader().getResourceAsStream(propertiesPath);
+        LogManager.getLogManager().readConfiguration(logConfig);
+
+
+        Logger.getLogger(LogConfiguration.class.getPackageName());
+    }
+}
@@ -1,6 +1,10 @@
 package ch.zhaw.projekt2.turnierverwaltung;

-public interface Participant {
+import java.io.Serializable;
+
+public interface Participant extends Serializable {
    String getName();
    void setName(String name);
+    boolean equals(Participant participant);
+    void change(Participant participant);
 }
@@ -1,11 +1,23 @@
 package ch.zhaw.projekt2.turnierverwaltung;

-public class Person {
+import java.io.Serializable;
+
+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 String name;
    private String firstName;
    private String phoneNumber;

-    public Person(String firstName, String name, String phoneNumber){
+    public Person(String firstName, String name, String phoneNumber) throws InvalidNameException, InvalidPhoneNumberException {
+        if(!firstName.matches(NAME_MATCHING_REGEX)){
+            throw new InvalidNameException("The First name is Invalid.");
+        } else if(!name.matches(NAME_MATCHING_REGEX)){
+            throw new InvalidNameException("The Last name is Invalid");
+        } else if(!phoneNumber.matches(PHONE_MATCHING_REGEX)){
+            throw new InvalidPhoneNumberException("The entered Phone Number is invalid.");
+        }
        setFirstName(firstName);
        setName(name);
        setPhoneNumber(phoneNumber);
@@ -34,4 +46,21 @@ public class Person {
    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }
+
+    public class InvalidPhoneNumberException extends Exception {
+        public InvalidPhoneNumberException() {
+            super();
+        }
+
+        public InvalidPhoneNumberException(String errorMessage) {
+            super(errorMessage);
+        }
+
+    }
+
+    @Override
+    public String toString(){
+        return firstName + " " + name;
+    }
+
 }
@@ -0,0 +1,36 @@
+package ch.zhaw.projekt2.turnierverwaltung;
+
+import java.io.Serializable;
+
+public class Place implements Serializable {
+    private final String NAME_MATCHING_REGEX = "[a-zA-Z0-9]{1,20}";
+    private String name;
+
+    public Place(String name) throws InvalidNameException {
+        if(!name.matches(NAME_MATCHING_REGEX)){
+            throw new InvalidNameException("The Name is Invalid.");
+        }
+        setName(name);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String toString(){
+        return name;
+    }
+
+    public boolean equals(Place place){
+        return name.equals(place.getName());
+    }
+
+    public void change(Place place) {
+        //TODO: If Place gets more developed in future releases
+    }
+}
@@ -1,21 +1,73 @@
 package ch.zhaw.projekt2.turnierverwaltung;

-import java.util.Date;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;

 public class Player extends Person implements Participant{

-    private Date dateOfBirth;
+    private LocalDate dateOfBirth;

-    public Player(String firstName, String name, String phoneNumber, Date dateOfBirth){
+    public Player(String firstName, String name, String phoneNumber, String dateOfBirth) throws InvalidNameException, InvalidPhoneNumberException, InvalidDateException {
        super(firstName, name, phoneNumber);
        setDateOfBirth(dateOfBirth);
    }

-    public Date getDateOfBirth() {
+    public LocalDate getDateOfBirth() {
        return dateOfBirth;
    }

-    public void setDateOfBirth(Date dateOfBirth) {
+    public String getFormatedDateOfBirth(){
+        try{
+            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd.MM.yyyy");
+            return dateOfBirth.format(formatter);
+        } catch (Exception e) {
+           //todo handle and logging
+            return "";
+        }
+    }
+
+    public void setDateOfBirth(String dateOfBirth) throws InvalidDateException {
+        if(dateOfBirth.length() > 0) {
+            String[] date = dateOfBirth.split("\\.");
+            try{
+                this.dateOfBirth = LocalDate.of(Integer.valueOf(date[2]), Integer.valueOf(date[1]), Integer.valueOf(date[0]));
+            } catch (NumberFormatException | IndexOutOfBoundsException e) {
+                e.printStackTrace();
+                throw new InvalidDateException("Date invalid");
+            }
+
+        } else {
+            dateOfBirth = null;
+        }
+    }
+
+    public void setDateOfBirth(LocalDate dateOfBirth) {
        this.dateOfBirth = dateOfBirth;
    }
+
+    @Override
+    public boolean equals(Participant participant) {
+        return getClass().equals(participant.getClass()) && toString().toLowerCase().equals(participant.toString().toLowerCase());
+    }
+
+    @Override
+    public void change(Participant participant) {
+        Player player = (Player) participant;
+        setDateOfBirth(player.getDateOfBirth());
+        setPhoneNumber(player.getPhoneNumber());
+    }
+
+    public class InvalidDateException extends Exception {
+        public InvalidDateException() {
+            super();
+        }
+
+        public InvalidDateException(String errorMessage) {
+            super(errorMessage);
+        }
+
+    }
+
 }
@@ -27,6 +27,24 @@ public class Team implements Participant {
        this.name = name;
    }

+    public void setPlayers(List<Player> players) {
+        this.players = players;
+    }
+
+    public List<Player> getPlayers() {
+        return players;
+    }
+
+    @Override
+    public boolean equals(Participant participant) {
+        return getClass().equals(participant.getClass()) && toString().toLowerCase().equals(participant.toString().toLowerCase());
+    }
+
+    @Override
+    public void change(Participant participant) {
+        return;
+    }
+
    public Person getContactPerson() {
        return contactPerson;
    }
@@ -34,4 +52,9 @@ public class Team implements Participant {
    public void setContactPerson(Person contactPerson) {
        this.contactPerson = contactPerson;
    }
+
+    @Override
+    public String toString(){
+        return name;
+    }
 }
@@ -1,19 +1,330 @@
 package ch.zhaw.projekt2.turnierverwaltung;

-import java.io.Serializable;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;

+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 final List<Participant> participants;
+    private final List<Place> places;
+    private List<List<Game>> gameList;

-    public Tournament(String name){
-        setName(name);
+    private static final Logger logger = Logger.getLogger(FileIO.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}")) {
+            logger.warning("The entered name is incorrect, Entered name: " + name);
+            throw new InvalidNameException("Invalid Name entered");
+        } 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");
+    }
+
+    /**
+     * Method used to save new Participant into the tournament, checking if participant already exists and if yes will
+     * edit the already existing participant
+     *
+     * @param newParticipant the Participant to be saved or edited
+     */
+    public void saveParticipant(Participant newParticipant) {
+        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
+     * @throws ParticipantNotExistsException
+     */
+    public void removeParticipant(Participant participant) throws ParticipantNotExistsException {
+        logger.finer("Trying to remove " + participant + " from participants List");
+        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;
+    }
+
+    /**
+     * Method to add a new Place, also checks if place does already exist.
+     *
+     * @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);
+    }
+
+    /**
+     * @param place
+     * @throws PlaceNotExistsException
+     */
+    public void removePlace(Place place) throws PlaceNotExistsException {
+        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;
    }

+    /**
+     * Settermethod for the name of the tournament
+     *
+     * @param name the new name that should be set
+     */
    public void setName(String name) {
        this.name = name;
    }
+
+    /**
+     * Gettermethod 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
+     */
+    public void setType(Type type) {
+        logger.fine("Setting the type of the tournament to: " + type);
+        this.type = type;
+    }
+
+    /**
+     * Gettermethod 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"); //Type GROUPS is not implemented in this prototype.
+
+        private String name;
+
+        private Type(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+
+        public static ObservableList<Type> getObservableList() {
+            ObservableList<Type> items = FXCollections.observableArrayList();
+            items.addAll(values());
+            return items;
+        }
+    }
+
+    /**
+     * Custom exception thrown when an invalid file is chosen
+     */
+    public class InvalidTypeException extends Exception {
+        public InvalidTypeException() {
+            super();
+        }
+
+        public InvalidTypeException(String errorMessage) {
+            super(errorMessage);
+        }
+
+    }
+
+    /**
+     * Custom Expeption thrown when a Participant does not exist
+     */
+    public class ParticipantNotExistsException extends Exception {
+        public ParticipantNotExistsException() {
+            super();
+        }
+
+        public ParticipantNotExistsException(String errorMessage) {
+            super(errorMessage);
+        }
+
+    }
+
+    /**
+     * Custom Exception thrown when a Place does not exist
+     */
+    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 class NumberOfParticipantInvalidException extends Exception {
+        public NumberOfParticipantInvalidException() {
+            super();
+        }
+
+        public NumberOfParticipantInvalidException(String msg) {
+            super(msg);
+        }
+    }
+
 }
@@ -0,0 +1,199 @@
+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;
+
+public class TournamentDecorator implements IsObservable{
+    private Tournament tournament;
+    private FileIO fileIO;
+    private List<IsObserver> listener = new ArrayList<>();
+    private ExecutorService executorService;
+    private FactoryDecorator factoryDecorator;
+
+    public TournamentDecorator(FileIO fileIO){
+        setFileIO(fileIO);
+        addListener(new IsObserver() {
+            @Override
+            public void update() {
+                if(tournament != null){
+
+                    saveTournament();
+                }
+            }
+        });
+        executorService = Executors.newFixedThreadPool(1);
+    }
+
+    public void setFactoryDecorator(FactoryDecorator factoryDecorator) {
+        this.factoryDecorator = factoryDecorator;
+    }
+
+    public void setFileIO(FileIO fileIO) {
+        this.fileIO = fileIO;
+    }
+
+    public void setTournament(Tournament tournament) {
+        this.tournament = tournament;
+    }
+
+    public Tournament getTournament() {
+        return tournament;
+    }
+
+    @Override
+    public void addListener(IsObserver observer) {
+        listener.add(observer);
+    }
+
+    @Override
+    public void removeListener(IsObserver observer) {
+        listener.remove(observer);
+    }
+
+
+    public void saveTournament(){
+        executorService.execute(new saveTask());
+        factoryDecorator.clearMessage(false);
+        factoryDecorator.printMessageToFooter("Zuletzt gespeichert: " + new Date().toString(),false);
+    }
+
+
+
+    public void createTournament(String name, Tournament.Type type){
+
+        try {
+            if(fileIO.tournamentExists(name)){
+                //TODO:Logger
+                factoryDecorator.printMessageToFooter("Turniername existiert bereits",true);
+                return;
+            }
+            Tournament tournament = new Tournament(name, type);
+            fileIO.saveTournament(tournament);
+            factoryDecorator.clearMessage(true);
+            informListener();
+        } catch (InvalidNameException e) {
+            e.printStackTrace();
+            //TODO: Logger
+            factoryDecorator.printMessageToFooter("Invalider Turniername",true);
+        } catch (Tournament.InvalidTypeException e) {
+            e.printStackTrace();
+            //TODO: Logger
+            factoryDecorator.printMessageToFooter("Turniermodus nicht moeglich",true);
+
+        } catch (IOException e) {
+            e.printStackTrace();
+            //TODO: Logger
+            factoryDecorator.printMessageToFooter("Fehler bei Dateizugriff",true);
+        }
+
+    }
+
+    public void deleteTournament(FileIO.TournamentFile tournamentFile){
+        try {
+            fileIO.deleteTournament(tournamentFile);
+            factoryDecorator.clearMessage(true);
+            informListener();
+        } catch (IOException e) {
+            e.printStackTrace();  //TODO handle and logging
+            factoryDecorator.printMessageToFooter("Fehler bei Dateizugriff",true);
+        }
+    }
+
+    public void createNewGameSchedule() {
+        //TODO: logging
+        try {
+            tournament.createGameSchedule();
+            factoryDecorator.clearMessage(true);
+        } catch (Tournament.NumberOfParticipantInvalidException e) {
+            e.printStackTrace();
+            factoryDecorator.printMessageToFooter("Anzahl Teilnehmer muss mindestens 4 betragen und eine Potenz von 2 sein.",true);
+        }
+        informListener();
+    }
+
+    public void savePlayer(String firstName, String name, String phoneNumber, String dateOfBirth){
+        try {
+            tournament.saveParticipant(new Player(firstName, name, phoneNumber, dateOfBirth));
+            factoryDecorator.clearMessage(true);
+            informListener();
+        } catch (InvalidNameException e) {
+            e.printStackTrace(); //TODO handle and logging
+            factoryDecorator.printMessageToFooter("Invalider Teilnehmername",true);
+        } catch (Person.InvalidPhoneNumberException e) {
+            e.printStackTrace(); //TODO handle and logging
+            factoryDecorator.printMessageToFooter("Invalide Telefonnummer",true);
+        } catch (Player.InvalidDateException e) {
+            e.printStackTrace();
+            factoryDecorator.printMessageToFooter("Ungueltiges Geburtsdatum", true);
+        }
+    }
+
+    public void deleteParticipant(Participant participant){
+        try {
+            tournament.removeParticipant(participant);
+            factoryDecorator.clearMessage(true);
+            informListener();
+        } catch (Tournament.ParticipantNotExistsException e) {
+            e.printStackTrace(); //TODO handle and logging
+            factoryDecorator.printMessageToFooter("Teilnehmer existiert nicht",true);
+
+        }
+    }
+
+    public void savePlace(String name){
+        try {
+            tournament.savePlace(new Place(name));
+            factoryDecorator.clearMessage(true);
+            informListener();
+        } catch (InvalidNameException e) {
+            e.printStackTrace(); //TODO handle and logging
+            factoryDecorator.printMessageToFooter("Invalider Ortsname",true);
+        }
+    }
+
+    public void deletePlace(Place place){
+        try {
+            tournament.removePlace(place);
+            factoryDecorator.clearMessage(true);
+            informListener();
+        } catch (Tournament.PlaceNotExistsException e) {
+            e.printStackTrace(); //TODO handle and logging
+            factoryDecorator.printMessageToFooter("Ort existiert nicht",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(() -> {
+                    factoryDecorator.printMessageToFooter("Datenzugriff nicht moeglich",true);
+                });
+            }
+        }
+    }
+
+}
@@ -1,35 +1,52 @@
 package ch.zhaw.projekt2.turnierverwaltung.main;

 import ch.zhaw.projekt2.turnierverwaltung.Factory;
+import ch.zhaw.projekt2.turnierverwaltung.FactoryDecorator;
 import ch.zhaw.projekt2.turnierverwaltung.FileIO;
+import ch.zhaw.projekt2.turnierverwaltung.TournamentDecorator;
 import javafx.application.Application;
+import javafx.event.EventHandler;
 import javafx.fxml.FXMLLoader;
 import javafx.scene.Scene;
 import javafx.scene.layout.BorderPane;
-import javafx.scene.layout.Pane;
 import javafx.stage.Stage;
+import javafx.stage.WindowEvent;
+
+import java.util.logging.Logger;

-import java.awt.*;
-import java.io.IOException;

 public class MainWindow extends Application {
-    private FileIO fileIO = new FileIO(System.getProperty("user.dir") + "/tournierverwaltung_angrynerds");
-    private Factory factory = new Factory(fileIO); //TODO make it private!
+    private FileIO fileIO = new FileIO(System.getProperty("user.dir") + System.getProperty("file.separator") + "tournierverwaltung_angrynerds");
+    private FactoryDecorator factoryDecorator;
+    private TournamentDecorator tournamentDecorator = new TournamentDecorator(fileIO);
+    private Factory factory = new Factory(fileIO, tournamentDecorator);
+    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());

    @Override
    public void start(Stage primaryStage) throws Exception {
-
        BorderPane pane = factory.loadMainWindow();
-        factory.loadTournamentList(pane);
-
+        factoryDecorator = new FactoryDecorator(fileIO, factory, pane);
+        factory.loadAllViews(factoryDecorator, pane);
+        tournamentDecorator.setFactoryDecorator(factoryDecorator);
+        factoryDecorator.openTournamentList();

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

-
+    @Override
+    public void stop() {
+        try {
+            super.stop();
+            tournamentDecorator.closeApplication();
+        } catch (Exception e) {
+            logger.warning("Exception while closing application");
+        }
+    }
 }
@@ -1,6 +1,7 @@
 package ch.zhaw.projekt2.turnierverwaltung.main;

 import ch.zhaw.projekt2.turnierverwaltung.FXController;
+import javafx.application.Platform;
 import javafx.event.ActionEvent;
 import javafx.fxml.FXML;

@@ -13,7 +14,7 @@ public class MainWindowController extends FXController {

    @FXML
    void closeApplication(ActionEvent event) {
-
+        Platform.exit();
    }

    @Override
@@ -0,0 +1,26 @@
+package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
+
+import javafx.scene.control.Alert;
+import javafx.scene.control.ButtonBar;
+import javafx.scene.control.ButtonType;
+
+public class AlertNewSchedule extends Alert {
+    private ButtonType yesButton = new ButtonType("Ja", ButtonBar.ButtonData.YES);
+    private ButtonType noButton = new ButtonType("Nein", ButtonBar.ButtonData.NO);
+    private boolean result;
+
+    public AlertNewSchedule() {
+        super(AlertType.WARNING);
+        setTitle("Neu erstellen");
+        setHeaderText("Spielplan neu erstellen?");
+        setContentText("Sind Sie sicher, dass Sie den Spielplan neu erstellen moechten?\nAlle Spielfortschritte gehen daraufhin verloren!");
+        getButtonTypes().setAll(yesButton,noButton);
+    }
+
+    public boolean showAndGetResult() {
+        showAndWait().ifPresent(input -> {
+            result = input == yesButton;
+        });
+        return result;
+    }
+}
@@ -0,0 +1,80 @@
+package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
+
+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{
+
+    private GameDecorator gameDecorator;
+
+    @FXML
+    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
+    void saveGameResult(Event event) {
+        gameDecorator.saveGameResult(pointsTeamOne.getText(), pointsTeamTwo.getText());
+    }
+
+
+    private void saveGamePlace(Place newPlace) {
+        gameDecorator.saveGamePlace(newPlace);
+    }
+
+    public double getGameBoxHeigth(){
+        return mainVBox.getPrefHeight();
+    }
+
+    @Override
+    public void loadContent() {
+        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) {
+        setTournamentDecorator(tournamentDecorator);
+        this.gameDecorator = gameDecorator;
+        placesChoiceBox.getSelectionModel().selectedItemProperty().addListener((ObservableValue<? extends Place> observable, Place oldValue, Place newValue) -> saveGamePlace(newValue == null ? oldValue : newValue));
+    }
+
+}
@@ -0,0 +1,82 @@
+package ch.zhaw.projekt2.turnierverwaltung.main.gameScheduleView;
+
+import ch.zhaw.projekt2.turnierverwaltung.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+public class GameDecorator implements IsObservable{
+    private Game game;
+    private List<IsObserver> listener = new ArrayList<>();
+
+    public GameDecorator (Game game) {
+        this.game = game;
+    }
+
+    @Override
+    public void addListener(IsObserver observer) {
+        listener.add(observer);
+    }
+
+    @Override
+    public void removeListener(IsObserver observer) {
+        listener.remove(observer);
+    }
+
+    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();
+    }
+
+    public void saveGamePlace(Place place){
+        game.setPlace(place);
+        informListener();
+    }
+
+    public String getPoints1() {
+       return String.valueOf(game.getPoints1());
+    }
+
+    public String getPoints2() {
+        return String.valueOf(game.getPoints2());
+    }
+
+    public String getParticipantOne() {
+        if (game.getParticipant1() != null) {
+            return game.getParticipant1().toString();
+        }
+        return "1";
+    }
+
+    public String getParticipantTwo() {
+        if (game.getParticipant2() != null) {
+            return game.getParticipant2().toString();
+        }
+        return "2";
+    }
+
+    public void refreshParticipants(){
+        game.refreshParticipants();
+        informListener();
+    }
+
+    public Place getPlace() {
+        return game.getPlace();
+    }
+
+    public void informListener() {
+        for(IsObserver observer : listener) {
+            observer.update();
+        }
+    }
+}
@@ -0,0 +1,67 @@
+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.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;
+
+    @FXML
+    void createNewSchedule(ActionEvent event) {
+        if (getTournamentDecorator().getTournament().getGameList().size() > 0) {
+            AlertNewSchedule alert = new AlertNewSchedule();
+            if (alert.showAndGetResult()) {
+                getTournamentDecorator().createNewGameSchedule();
+            }
+        } else {
+            getTournamentDecorator().createNewGameSchedule();
+        }
+    }
+
+    @FXML
+    void openPlacesFormular(ActionEvent event) {
+        getFactoryDecorator().openPlacesFormular();
+    }
+
+    @FXML
+    void openParticipantFormular(ActionEvent event) {
+        getFactoryDecorator().openParticipantFormular();
+    }
+
+    @FXML
+    void closeTournament(ActionEvent event) {
+        getFactoryDecorator().openTournamentList();
+    }
+
+    @FXML
+    void changeView(ActionEvent event) {
+        loadContent();
+    }
+
+    @Override
+    public void loadContent() {
+        getFactoryDecorator().loadGameList(hBoxCenter, getTournamentDecorator(), treeView.isSelected());
+    }
+}
+
@@ -0,0 +1,113 @@
+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;
+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;
+
+public class ParticipantFormularController 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 newParticipantFormularTitle;
+
+    @FXML
+    private Button closeBtn;
+
+    @FXML
+    private Button deleteBtn;
+
+
+    @FXML
+    private Label participantListTitle;
+
+    @FXML
+    private ListView<Participant> participantListView;
+
+    @FXML
+    private Label participantNameLabel;
+
+    @FXML
+    private TextField participantNameTextField;
+
+    @FXML
+    private Label phoneNumberLabel;
+
+    @FXML
+    private TextField phoneNumberTextField;
+
+    @FXML
+    private Button saveBtn;
+
+    @FXML
+    void changedSelection(MouseEvent event){
+        Player participant = (Player) participantListView.getSelectionModel().getSelectedItems().get(0);
+        participantNameTextField.setText(participant.getName());
+        firstNameTextField.setText(participant.getFirstName());
+        phoneNumberTextField.setText(participant.getPhoneNumber());
+        birthDateTextField.setText(participant.getFormatedDateOfBirth());
+    }
+
+    @FXML
+    void saveParticipant(ActionEvent event) {
+        getTournamentDecorator().savePlayer(firstNameTextField.getText(), participantNameTextField.getText(), phoneNumberTextField.getText(), birthDateTextField.getText());
+        clearFormular();
+    }
+
+    private void clearFormular() {
+        firstNameTextField.clear();
+        participantNameTextField.clear();
+        phoneNumberTextField.clear();
+        birthDateTextField.clear();
+    }
+
+    @FXML
+    void delete(ActionEvent event) {
+        Participant participant = participantListView.getSelectionModel().getSelectedItems().get(0);
+        getTournamentDecorator().deleteParticipant(participant);
+    }
+
+    @FXML
+    void close(ActionEvent event) {
+        getFactoryDecorator().openScheduleView();
+    }
+
+    @Override
+    public void loadContent() {
+        Tournament tournament = getTournamentDecorator().getTournament();
+        if(tournament != null){
+            participantListView.setItems(tournament.getParticipants());
+        } else {
+            participantListView.getItems().clear();
+        }
+    }
+}
@@ -1,83 +0,0 @@
-package ch.zhaw.projekt2.turnierverwaltung.main.participantAddFormular;
-
-import ch.zhaw.projekt2.turnierverwaltung.FXController;
-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;
-
-public class ParticipantFormularController 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 newParticipantFormularTitle;
-
-    @FXML
-    private Button openBtn;
-
-    @FXML
-    private Label participantListTitle;
-
-    @FXML
-    private ListView<?> participantListView;
-
-    @FXML
-    private Label participantNameLabel;
-
-    @FXML
-    private TextField participantNameTextField;
-
-    @FXML
-    private Label phoneNumberLabel;
-
-    @FXML
-    private TextField phoneNumberTextField;
-
-    @FXML
-    private Button saveBtn;
-
-    @FXML
-    void addParticipant(ActionEvent event) {
-
-    }
-
-    @FXML
-    void changeParticipant(MouseEvent event) {
-
-    }
-
-    @FXML
-    void save(ActionEvent event) {
-
-    }
-
-    @Override
-    public void loadContent() {
-
-    }
-}
@@ -0,0 +1,89 @@
+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;
+
+public class PlacesFormularController extends FXController {
+
+    @FXML
+    private Button addBtn;
+
+    @FXML
+    private VBox changeBtn;
+
+    @FXML
+    private GridPane grid;
+
+    @FXML
+    private Label newPlaceFormularTitle;
+
+    @FXML
+    private Button closeBtn;
+
+    @FXML
+    private Button deleteBtn;
+
+
+    @FXML
+    private Label placeListTitle;
+
+    @FXML
+    private ListView<Place> placeListView;
+
+    @FXML
+    private Label placeNameLabel;
+
+    @FXML
+    private TextField placeNameTextField;
+
+    @FXML
+    private Button saveBtn;
+
+    @FXML
+    void changedSelection(MouseEvent event){
+        Place place = placeListView.getSelectionModel().getSelectedItems().get(0);
+        placeNameTextField.setText(place.getName());
+    }
+
+    @FXML
+    void savePlace(ActionEvent event) {
+        getTournamentDecorator().savePlace(placeNameTextField.getText());
+        clearFormular();
+    }
+
+    private void clearFormular() {
+        placeNameTextField.clear();
+    }
+
+    @FXML
+    void delete(ActionEvent event) {
+        Place place = placeListView.getSelectionModel().getSelectedItems().get(0);
+        getTournamentDecorator().deletePlace(place);
+    }
+
+    @FXML
+    void close(ActionEvent event) {
+        getFactoryDecorator().openScheduleView();
+    }
+
+    @Override
+    public void loadContent() {
+        Tournament tournament = getTournamentDecorator().getTournament();
+        if(tournament != null){
+            placeListView.setItems(tournament.getPlaces());
+        } else {
+            placeListView.getItems().clear();
+        }
+    }
+}
@@ -0,0 +1,30 @@
+package ch.zhaw.projekt2.turnierverwaltung.main.tournamentList;
+
+import javafx.scene.control.Alert;
+import javafx.scene.control.ButtonBar;
+import javafx.scene.control.ButtonType;
+
+public class AlertDelete extends Alert {
+    ButtonType yesButton = new ButtonType("Ja", ButtonBar.ButtonData.YES);
+    ButtonType noButton = new ButtonType("Nein", ButtonBar.ButtonData.NO);
+    Boolean result;
+
+    public AlertDelete(String name){
+        super(Alert.AlertType.WARNING);
+        setTitle("Entfernen");
+        setHeaderText("Turnier entfernen?");
+        setContentText("Sind Sie sicher, dass sie das Turnier " + name + " entfernen wollen?\n" +
+                "Nach diesem Vorgang kann es nicht wiederhergestellt werden.");
+        getButtonTypes().setAll(yesButton, noButton);
+    }
+
+    public boolean showAndGetResult() {
+        result = false;
+        showAndWait().ifPresent(type -> {
+            result = type == yesButton;
+        });
+        return result;
+    }
+
+
+}
@@ -0,0 +1,84 @@
+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;
+import javafx.event.ActionEvent;
+import javafx.fxml.FXML;
+import javafx.scene.control.*;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.GridPane;
+
+import java.io.File;
+import java.io.IOException;
+
+public class TournamentListController extends FXController {
+
+    @FXML
+    public void initialize(){
+        modusChoiceBox.setItems(Tournament.Type.getObservableList());
+    }
+
+    @FXML
+    private Button createBtn;
+
+    @FXML
+    private GridPane grid;
+
+    @FXML
+    private ChoiceBox<Tournament.Type> modusChoiceBox;
+
+    @FXML
+    private Label newTournamentFormularTitle;
+
+    @FXML
+    private Button openBtn;
+
+    @FXML
+    private Button deleteBtn;
+
+    @FXML
+    private Label tournamentListTitle;
+
+    @FXML
+    private ListView<FileIO.TournamentFile> tournamentListView;
+
+    @FXML
+    private Label tournamentModLabel;
+
+    @FXML
+    private Label tournamentNameLabel;
+
+    @FXML
+    private TextField tournamentNameField;
+
+    @FXML
+    void createTournament(ActionEvent event) {
+        getTournamentDecorator().createTournament(tournamentNameField.getText(), modusChoiceBox.getValue());
+    }
+
+    @FXML
+    void openTournament(ActionEvent event) {
+        FileIO.TournamentFile tournamentFile = tournamentListView.getSelectionModel().getSelectedItems().get(0);
+        getFactoryDecorator().openTournament(tournamentFile);
+    }
+
+    @FXML
+    void deleteTournament(ActionEvent event) {
+        FileIO.TournamentFile tournamentFile = tournamentListView.getSelectionModel().getSelectedItems().get(0);
+        AlertDelete alert = new AlertDelete(tournamentFile.toString());
+        if(alert.showAndGetResult()){
+           getTournamentDecorator().deleteTournament(tournamentFile);
+        }
+    }
+
+    @Override
+    public void loadContent() {
+        tournamentListView.setItems(getFileIO().getList());
+        tournamentNameField.clear();
+    }
+}
+
@@ -1,79 +0,0 @@
-package ch.zhaw.projekt2.turnierverwaltung.main.tournamentList;
-
-import ch.zhaw.projekt2.turnierverwaltung.FXController;
-import ch.zhaw.projekt2.turnierverwaltung.Factory;
-import ch.zhaw.projekt2.turnierverwaltung.FileIO;
-import ch.zhaw.projekt2.turnierverwaltung.Tournament;
-import ch.zhaw.projekt2.turnierverwaltung.main.MainWindow;
-import javafx.beans.Observable;
-import javafx.collections.FXCollections;
-import javafx.collections.ObservableList;
-import javafx.event.ActionEvent;
-import javafx.fxml.FXML;
-import javafx.scene.control.Button;
-import javafx.scene.control.ChoiceBox;
-import javafx.scene.control.Label;
-import javafx.scene.control.ListView;
-import javafx.scene.layout.BorderPane;
-import javafx.scene.layout.GridPane;
-
-import java.io.File;
-import java.io.IOException;
-
-public class TournamentListController extends FXController {
-
-    @FXML
-    private Button createBtn;
-
-    @FXML
-    private GridPane grid;
-
-    @FXML
-    private ChoiceBox<?> modusChoiceBox;
-
-    @FXML
-    private Label newTournamentFormularTitle;
-
-    @FXML
-    private Button openBtn;
-
-    @FXML
-    private Label tournierListTitle;
-
-    @FXML
-    private ListView<File> tournierListView;
-
-    @FXML
-    private Label tournierModLabel;
-
-    @FXML
-    private Label turnierNameLabel;
-
-    @FXML
-    void createTournament(ActionEvent event) {
-
-    }
-
-    @FXML
-    void openTournament(ActionEvent event) {
-        try {
-            File tournamentFile = tournierListView.getSelectionModel().getSelectedItems().get(0);
-            getFactory().setTournament(getFileIO().loadTournament(tournamentFile));
-            getFactory().loadParticipantFormular((BorderPane) getPane());
-        } catch (IOException e) {
-            e.printStackTrace();
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    public void loadContent() {
-        ObservableList<File> tournamentFiles = FXCollections.observableArrayList();
-        for(File tournament : getFileIO().getList()){
-            tournamentFiles.add(tournament);
-        }
-        tournierListView.setItems(tournamentFiles);
-    }
-}
-
@@ -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>
@@ -34,4 +34,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>
@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.Insets?>
+<?import javafx.scene.control.ChoiceBox?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.TextField?>
+<?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">
+   <children>
+      <VBox fx:id="mainVBox" alignment="CENTER" maxHeight="1.7976931348623157E308" maxWidth="1.7976931348623157E308" prefHeight="90.0">
+         <children>
+            <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0">
+               <children>
+                  <Label fx:id="participantNameOne" style="-fx-font-weight: bold;" text="Participant One">
+                     <HBox.margin>
+                        <Insets right="20.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 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>
+      </VBox>
+   </children>
+</VBox>
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?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">
+   <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_LEFT" prefHeight="100.0" prefWidth="200.0" BorderPane.alignment="CENTER">
+         <children>
+            <CheckBox fx:id="treeView" mnemonicParsing="false" onAction="#changeView" selected="true" text="Baumansicht">
+               <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 fx:id="editParticipantBtn" mnemonicParsing="false" onAction="#openParticipantFormular" text="Teilnehmer bearbeiten">
+               <HBox.margin>
+                  <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>
+      </HBox>
+   </top>
+</BorderPane>
@@ -0,0 +1,33 @@
+## configures handlers
+java.util.logging.ConsoleHandler.level = ALL
+
+## File handler configuration
+## see https://docs.oracle.com/en/java/javase/11/docs/api/java.logging/java/util/logging/FileHandler.html
+java.util.logging.FileHandler.level = ALL
+# %g = generation number, %u = unique number to resolve conflicts
+java.util.logging.FileHandler.pattern = tournierverwaltung_angrynerds/log_files/log-%g-%u.log
+# use SimpleFormatter instead of default XMLFormatter
+java.util.logging.FileHandler.formatter = java.util.logging.SimpleFormatter
+java.util.logging.FileHandler.encoding = UTF-8
+# max log file size in byte before switching to next generation (=1kB); 0=unlimited
+java.util.logging.FileHandler.limit = 2048
+# max number of generations (%g) before overwriting (5 -> 0..4)
+java.util.logging.FileHandler.count=10
+java.util.logging.FileHandler.append=true
+
+## configures Formatter
+java.util.logging.SimpleFormatter.format = [%1$tc] %4$s: %5$s {%2$s}%6$s%n
+
+## configures default log level (for all loggers, if not overwritten below)
+.level = INFO
+
+## configure root logger ""
+handlers = java.util.logging.ConsoleHandler, java.util.logging.FileHandler
+level = FINE
+
+
+
+#ch.zhaw.prog2.turnierverwaltung.useParentHandlers = false
+
+# logger level for individual classes
+ch.zhaw.projekt2.turnierverwaltung.FileIO.level = FINEST
@@ -1,15 +1,10 @@
 <?xml version="1.0" encoding="UTF-8"?>
-
 <?import javafx.geometry.Insets?>
 <?import javafx.scene.control.Button?>
 <?import javafx.scene.control.Label?>
 <?import javafx.scene.control.ListView?>
-<?import javafx.scene.control.Menu?>
-<?import javafx.scene.control.MenuBar?>
-<?import javafx.scene.control.MenuItem?>
 <?import javafx.scene.control.Separator?>
 <?import javafx.scene.control.TextField?>
-
 <?import javafx.scene.layout.ColumnConstraints?>
 <?import javafx.scene.layout.GridPane?>
 <?import javafx.scene.layout.HBox?>
@@ -17,7 +12,7 @@
 <?import javafx.scene.layout.VBox?>
 <?import javafx.scene.text.Font?>

-<HBox alignment="CENTER" VBox.vgrow="ALWAYS" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.participantAddFormular.ParticipantFormularController">
+<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.participantAddFormular.ParticipantFormularController">
   <children>
      <VBox alignment="TOP_CENTER" prefHeight="331.0" prefWidth="308.0" HBox.hgrow="ALWAYS">
         <children>
@@ -29,19 +24,23 @@
                  <Insets bottom="20.0" />
               </VBox.margin>
            </Label>
-            <ListView fx:id="participantListView" prefHeight="200.0" prefWidth="200.0" VBox.vgrow="ALWAYS">
+            <ListView fx:id="participantListView" onMouseClicked="#changedSelection" prefHeight="200.0" prefWidth="200.0" VBox.vgrow="ALWAYS">
               <VBox.margin>
                  <Insets />
               </VBox.margin>
            </ListView>
            <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0" VBox.vgrow="ALWAYS">
               <children>
-                  <Button fx:id="saveBtn" mnemonicParsing="false" onAction="#save" text="Save">
+                  <Button fx:id="closeBtn" mnemonicParsing="false" onAction="#close" text="Schliessen">
+                     <HBox.margin>
+                        <Insets right="40.0" />
+                     </HBox.margin>
+                  </Button>
+                  <Button fx:id="deleteBtn" mnemonicParsing="false" onAction="#delete" text="Löschen">
                     <HBox.margin>
                        <Insets right="40.0" />
                     </HBox.margin>
                  </Button>
-                  <Button fx:id="openBtn" mnemonicParsing="false" text="Bearbeiten" />
               </children>
            </HBox>
         </children>
@@ -54,9 +53,9 @@
            <Insets left="10.0" right="10.0" />
         </HBox.margin>
      </Separator>
-      <VBox fx:id="changeBtn" alignment="TOP_CENTER" onDragDetected="#changeParticipant" prefHeight="331.0" prefWidth="308.0" HBox.hgrow="ALWAYS">
+      <VBox fx:id="changeBtn" alignment="TOP_CENTER" prefHeight="331.0" prefWidth="308.0" HBox.hgrow="ALWAYS">
         <children>
-            <Label fx:id="newParticipantFormularTitle" text="Neuer Teilnehmer">
+            <Label fx:id="newParticipantFormularTitle" text="Teilnehmer ändern/erstellen">
               <font>
                  <Font name="System Bold" size="21.0" />
               </font>
@@ -100,7 +99,7 @@
               </children>
            </GridPane>
            <Separator prefWidth="200.0" />
-            <Button fx:id="addBtn" alignment="TOP_LEFT" mnemonicParsing="false" onAction="#addParticipant" text="Erstellen" VBox.vgrow="ALWAYS">
+            <Button fx:id="saveBtn" alignment="TOP_LEFT" mnemonicParsing="false" onAction="#saveParticipant" text="Speichern" VBox.vgrow="ALWAYS">
               <VBox.margin>
                  <Insets bottom="10.0" top="30.0" />
               </VBox.margin>
@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.geometry.*?>
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.*?>
+<?import javafx.scene.text.*?>
+
+<HBox alignment="CENTER" VBox.vgrow="ALWAYS" xmlns="http://javafx.com/javafx/11.0.2" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.placesAddFormular.PlacesFormularController">
+   <children>
+      <VBox alignment="TOP_CENTER" prefHeight="331.0" prefWidth="308.0" HBox.hgrow="ALWAYS">
+         <children>
+            <Label fx:id="placeListTitle" text="Hinzugefügt">
+               <font>
+                  <Font name="System Bold" size="21.0" />
+               </font>
+               <VBox.margin>
+                  <Insets bottom="20.0" />
+               </VBox.margin>
+            </Label>
+            <ListView fx:id="placeListView" onMouseClicked="#changedSelection" prefHeight="200.0" prefWidth="200.0" VBox.vgrow="ALWAYS">
+               <VBox.margin>
+                  <Insets />
+               </VBox.margin>
+            </ListView>
+            <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0" VBox.vgrow="ALWAYS">
+               <children>
+                  <Button fx:id="closeBtn" mnemonicParsing="false" onAction="#close" text="Schliessen">
+                     <HBox.margin>
+                        <Insets right="40.0" />
+                     </HBox.margin>
+                  </Button>
+                  <Button fx:id="deleteBtn" mnemonicParsing="false" onAction="#delete" text="Löschen">
+                     <HBox.margin>
+                        <Insets right="40.0" />
+                     </HBox.margin>
+                  </Button>
+               </children>
+            </HBox>
+         </children>
+         <HBox.margin>
+            <Insets left="40.0" />
+         </HBox.margin>
+      </VBox>
+      <Separator orientation="VERTICAL" prefHeight="200.0">
+         <HBox.margin>
+            <Insets left="10.0" right="10.0" />
+         </HBox.margin>
+      </Separator>
+      <VBox fx:id="changeBtn" alignment="TOP_CENTER" prefHeight="331.0" prefWidth="308.0" HBox.hgrow="ALWAYS">
+         <children>
+            <Label fx:id="newplaceFormularTitle" text="Ort ändern/erstellen">
+               <font>
+                  <Font name="System Bold" size="21.0" />
+               </font>
+               <VBox.margin>
+                  <Insets bottom="40.0" />
+               </VBox.margin>
+            </Label>
+            <Separator prefWidth="200.0" />
+            <GridPane fx:id="grid" prefHeight="200.0">
+               <columnConstraints>
+                  <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+                  <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
+               </columnConstraints>
+               <rowConstraints>
+                  <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+                  <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+                  <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+                  <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
+               </rowConstraints>
+               <children>
+                  <Label fx:id="placeNameLabel" styleClass="lableGrid" text="Name">
+                     <GridPane.margin>
+                        <Insets />
+                     </GridPane.margin>
+                  </Label>
+                  <TextField fx:id="placeNameTextField" styleClass="inputGrid" GridPane.columnIndex="1">
+                     <GridPane.margin>
+                        <Insets />
+                     </GridPane.margin>
+                  </TextField>
+               </children>
+            </GridPane>
+            <Separator prefWidth="200.0" />
+            <Button fx:id="saveBtn" alignment="TOP_LEFT" mnemonicParsing="false" onAction="#savePlace" text="Speichern" VBox.vgrow="ALWAYS">
+               <VBox.margin>
+                  <Insets bottom="10.0" top="30.0" />
+               </VBox.margin>
+            </Button>
+         </children>
+         <HBox.margin>
+            <Insets right="40.0" />
+         </HBox.margin>
+      </VBox>
+   </children>
+</HBox>
@@ -1,24 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>

-<?import javafx.geometry.Insets?>
-<?import javafx.scene.control.Button?>
-<?import javafx.scene.control.ChoiceBox?>
-<?import javafx.scene.control.Label?>
-<?import javafx.scene.control.ListView?>
-<?import javafx.scene.control.Separator?>
-<?import javafx.scene.control.TextField?>
-<?import javafx.scene.layout.ColumnConstraints?>
-<?import javafx.scene.layout.GridPane?>
-<?import javafx.scene.layout.HBox?>
-<?import javafx.scene.layout.RowConstraints?>
-<?import javafx.scene.layout.VBox?>
-<?import javafx.scene.text.Font?>
+<?import javafx.geometry.*?>
+<?import javafx.scene.control.*?>
+<?import javafx.scene.layout.*?>
+<?import javafx.scene.text.*?>

-<HBox alignment="CENTER" VBox.vgrow="ALWAYS" xmlns="http://javafx.com/javafx/17" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.tournamentList.TournamentListController">
+<HBox alignment="CENTER" VBox.vgrow="ALWAYS" xmlns="http://javafx.com/javafx/11.0.2" xmlns:fx="http://javafx.com/fxml/1" fx:controller="ch.zhaw.projekt2.turnierverwaltung.main.tournamentList.TournamentListController">
    <children>
        <VBox alignment="TOP_CENTER" prefHeight="331.0" prefWidth="308.0" HBox.hgrow="ALWAYS">
            <children>
-                <Label fx:id="tournierListTitle" text="Bestehende Turniere">
+                <Label fx:id="tournamentListTitle" text="Bestehende Turniere">
                    <font>
                        <Font name="System Bold" size="21.0" />
                    </font>
@@ -26,16 +17,26 @@
                        <Insets bottom="20.0" />
                    </VBox.margin>
                </Label>
-                <ListView fx:id="tournierListView" prefHeight="200.0" prefWidth="200.0" VBox.vgrow="ALWAYS">
+                <ListView fx:id="tournamentListView" prefHeight="200.0" prefWidth="200.0" VBox.vgrow="ALWAYS">
                    <VBox.margin>
                        <Insets />
                    </VBox.margin>
                </ListView>
-                <Button fx:id="openBtn" mnemonicParsing="false" onAction="#openTournament" text="Öffnen">
+            <HBox alignment="CENTER" prefHeight="100.0" prefWidth="200.0">
               <VBox.margin>
                  <Insets bottom="20.0" top="40.0" />
               </VBox.margin>
-                </Button>
+               <children>
+                      <Button fx:id="openBtn" mnemonicParsing="false" onAction="#openTournament" text="Öffnen">
+                     <HBox.margin>
+                        <Insets right="40.0" />
+                     </HBox.margin></Button>
+                  <Button fx:id="deleteBtn" layoutX="138.0" layoutY="28.0" mnemonicParsing="false" onAction="#deleteTournament" text="Löschen">
+                     <HBox.margin>
+                        <Insets />
+                     </HBox.margin></Button>
+               </children>
+            </HBox>
            </children>
            <HBox.margin>
                <Insets left="40.0" />
@@ -66,17 +67,17 @@
                        <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                    </rowConstraints>
                    <children>
-                        <Label fx:id="turnierNameLabel" styleClass="lableGrid" text="Turnier Name:">
+                        <Label fx:id="tournamentNameLabel" styleClass="lableGrid" text="Turnier Name:">
                            <GridPane.margin>
                                <Insets />
                            </GridPane.margin>
                        </Label>
-                        <TextField styleClass="inputGrid" GridPane.columnIndex="1">
+                        <TextField fx:id="tournamentNameField" styleClass="inputGrid" GridPane.columnIndex="1">
                            <GridPane.margin>
                                <Insets />
                            </GridPane.margin>
                        </TextField>
-                        <Label fx:id="tournierModLabel" styleClass="lableGrid" text="Turnier Modus:" GridPane.rowIndex="1">
+                        <Label fx:id="tournamentModLabel" styleClass="lableGrid" text="Turnier Modus:" GridPane.rowIndex="1">
                            <GridPane.margin>
                                <Insets />
                            </GridPane.margin>
@@ -82,19 +82,19 @@ class FileIOTest {

        @Test
        void loadTournamentNotExisting(){
-            io = new FileIO(mainDir);
-            assertThrows(FileNotFoundException.class, () -> io.loadTournament(new File("Not-existing-File")));
+            File file = new File("Not-existing-File");
+            assertFalse(file.exists());
+            assertThrows(FileNotFoundException.class, () -> io.loadTournament(file));
+            assertFalse(file.exists());
        }

        @Test
        void loadTournamentEmpty(){
-            io = new FileIO(mainDir);
            assertThrows(IOException.class, () -> io.loadTournament(new File(mainDir + "/saves/empty.txt")));
        }

        @Test
        void loadTournamentFileNull(){
-            io = new FileIO(mainDir);
            assertThrows(IllegalArgumentException.class, () -> io.loadTournament(null));
        }
    }
@@ -108,15 +108,14 @@ class FileIOTest {
        }

        @Test
-        void saveTournament() throws IOException {
-            Tournament tournament = new Tournament("test1");
+        void saveTournament() throws IOException, InvalidNameException, Tournament.InvalidTypeException {
+            Tournament tournament = null;
+            tournament = new Tournament("test1", Tournament.Type.KO);
            io.saveTournament(tournament);
            File file = new File(mainDir + "/saves/test1.txt");
-            if(file.exists()){
-                file.delete();
-            } else {
-                fail();
-            }
+            assertTrue(file.exists());
+            assertTrue(file.delete());
+            assertFalse(file.exists());
        }

        @Test
@@ -124,4 +123,35 @@ class FileIOTest {
            assertThrows(IllegalArgumentException.class, () -> io.saveTournament(null));
        }
    }
+
+    @Nested
+    class Delete{
+        @BeforeEach
+        void setup(){
+            mainDir = RESOURCES_DIR + "FileIODelete";
+            io = new FileIO(mainDir);
+        }
+
+        @Test
+        void deleteTournament() throws IOException {
+            File file = new File(mainDir + "/saves/test1.txt");
+            file.createNewFile();
+            assertTrue(file.exists());
+            io.deleteTournament(file);
+            assertFalse(file.exists());
+        }
+
+        @Test
+        void deleteTournamentNotExisting() throws IOException {
+            File file = new File("Not-existing-File");
+            assertFalse(file.exists());
+            assertThrows(FileNotFoundException.class, () -> io.deleteTournament(file));
+            assertFalse(file.exists());
+        }
+
+        @Test
+        void deleteTournamentNull(){
+            assertThrows(IllegalArgumentException.class, () -> io.deleteTournament(null));
+        }
+    }
 }
@@ -0,0 +1,147 @@
+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);
+
+            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());
+
+        }
+
+        @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));
+
+            //Checks if participant gets removed
+            tournament.saveParticipant(participant);
+            assertEquals(1, tournament.getParticipants().size());
+            try {
+                tournament.removeParticipant(participant);
+                assertEquals(0, tournament.getParticipants().size());
+            } catch (Tournament.ParticipantNotExistsException e) {
+                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 e) {
+                        fail();
+                    }
+
+                } else {
+                    assertThrows(Tournament.NumberOfParticipantInvalidException.class, () -> tournament.createGameSchedule());
+                    tournament.saveParticipant(participant);
+                }
+            }
+            try {
+                tournament.createGameSchedule();
+            } catch (Tournament.NumberOfParticipantInvalidException e) {
+                fail();
+            }
+            assertEquals(3, tournament.getGameList().size());
+        }
+
+    }
+}
@@ -46,7 +46,7 @@ echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 echo.
 echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo place of your Java installation.

 goto fail

@@ -60,7 +60,7 @@ echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
 echo.
 echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo place of your Java installation.

 goto fail
Author	SHA1	Message	Date
schrom01	a1b73e22ca	removed "äöü" from error messages.	2022-05-13 17:51:04 +02:00
schrom01	11d6ca1852	changed error Message numberOfParticipants.	2022-05-13 17:10:32 +02:00
schrom01	a78d1d9de7	changed error Message numberOfParticipants.	2022-05-13 16:51:17 +02:00
schrom01	5f6193d8b2	Merge branch 'main' into develop_footer # Conflicts: # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Tournament.java	2022-05-13 16:50:35 +02:00
Roman SchenkandGitHub Enterprise	3d522dd13c	Merge pull request #49 from PM2-IT21bWIN-ruiz-mach-krea/gameSchedule_Alert Create alert popup if user wants to create new game schedule	2022-05-13 16:12:29 +02:00
Andrin Fassbind	7dea7919c5	AlertDelete shortened code	2022-05-13 16:12:06 +02:00
fassbandandGitHub Enterprise	f575bb94d3	Merge pull request #48 from PM2-IT21bWIN-ruiz-mach-krea/fixes_in_layout Fixes in layout	2022-05-13 16:06:23 +02:00
Andrin Fassbind	55517a531e	Create alert popup if user wants to create new game schedule	2022-05-13 16:04:19 +02:00
schrom01	53cf3bdacc	rmeoved tournament Type GROUPS from Tournament Enum Type.	2022-05-13 15:58:58 +02:00
schrom01	c862492be3	fixes in Layout solved #34	2022-05-13 15:57:39 +02:00
fassbandandGitHub Enterprise	a6f14b94bd	Merge pull request #47 from PM2-IT21bWIN-ruiz-mach-krea/fix_places_are_deleted_ fixed places are deleted.	2022-05-13 15:38:42 +02:00
Roman SchenkandGitHub Enterprise	d3472017bb	Merge pull request #46 from PM2-IT21bWIN-ruiz-mach-krea/closeImplementation Make Application close properly	2022-05-13 15:37:31 +02:00
schrom01	0a7ca1ac3e	fixed places are deleted. solved #45	2022-05-13 15:36:29 +02:00
Andrin Fassbind	bdb34fde31	Make Application close properly If exception while closing there is a proper log	2022-05-13 15:35:41 +02:00
Roman SchenkandGitHub Enterprise	20903f6a69	Merge pull request #44 from PM2-IT21bWIN-ruiz-mach-krea/refactoring_of_factory refactoring of Factory.java	2022-05-13 15:17:15 +02:00
Roman SchenkandGitHub Enterprise	e9d42b719b	Merge branch 'main' into refactoring_of_factory	2022-05-13 15:16:51 +02:00
Roman SchenkandGitHub Enterprise	1d6fcce13f	Merge pull request #42 from PM2-IT21bWIN-ruiz-mach-krea/testClass Test class	2022-05-13 15:16:05 +02:00
Andrin Fassbind	b4da0b2fef	Changed number of threads in executerservice to one to prevent false order to save file	2022-05-13 15:15:37 +02:00
schrom01	6c761c944f	refactoring of Factory.java added Enum View solved #23	2022-05-13 15:08:26 +02:00
Andrin Fassbind	127e152637	implement TournamentTest	2022-05-13 14:52:58 +02:00
Andrin Fassbind	40cfd69436	implement TournamentTest	2022-05-13 14:23:17 +02:00
schrom01	54a428cde2	throw PlaceExistsExceptoin if place exists already.	2022-05-13 13:48:38 +02:00
Andrin Fassbind	03c9da13a5	Merge remote-tracking branch 'origin/main' into testClass	2022-05-13 13:14:39 +02:00
Andrin Fassbind	f81b031555	Merge remote-tracking branch 'origin/main' into testClass # Conflicts: # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Tournament.java	2022-05-12 23:31:42 +02:00
fassbandandGitHub Enterprise	92d121890c	Merge pull request #39 from PM2-IT21bWIN-ruiz-mach-krea/develop_footer Develop footer	2022-05-12 23:26:54 +02:00
schrom01	280d2ebda3	fixed Error when IndexOutOfBoundsException in setDateofBirtch in Player.java	2022-05-12 23:21:17 +02:00
Andrin Fassbind	68080c36ff	change method addPlace start TournamentTest implementation	2022-05-12 23:15:42 +02:00
Roman SchenkandGitHub Enterprise	3315b7f9c1	Merge pull request #37 from PM2-IT21bWIN-ruiz-mach-krea/logging_and_docs java doc and logging added to class Tournament	2022-05-12 22:56:45 +02:00
Roman SchenkandGitHub Enterprise	1031c27650	Merge branch 'main' into logging_and_docs	2022-05-12 22:54:43 +02:00
Leonardo Brandenberger	e77d6cbc21	java doc and logging added to class Tournament	2022-05-12 22:51:05 +02:00
schrom01	ddfbb9bbd0	added error Message for file reading error	2022-05-12 22:45:10 +02:00
schrom01	3ebf9c5072	added Exception for Invalid Date	2022-05-12 22:41:18 +02:00
Roman SchenkandGitHub Enterprise	f8e4dadcfb	Merge pull request #35 from PM2-IT21bWIN-ruiz-mach-krea/develop_footer Develop message footer	2022-05-12 22:09:38 +02:00
Andrin Fassbind	f885092259	removed import	2022-05-12 21:08:48 +02:00
Andrin Fassbind	2784cd67fa	make last file visible for user in footer	2022-05-12 19:44:45 +02:00
Andrin Fassbind	298d61eeca	extent scope of FactoryDecorator for TournamentDecorator creat footer to show error msg if user acts not as expected	2022-05-12 19:34:59 +02:00
fassbandandGitHub Enterprise	b0aa0ab1ad	Merge pull request #33 from PM2-IT21bWIN-ruiz-mach-krea/develope_Game_branch Develope game branch	2022-05-12 13:44:47 +02:00
Andrin Fassbind	84b5f2464d	test performance with separete thread to save and load file	2022-05-12 13:38:53 +02:00
Andrin Fassbind	d3a4b4cc87	if game points empty default value is 0 changed to variable names	2022-05-12 13:23:15 +02:00
Roman SchenkandGitHub Enterprise	4b74a8d285	Merge pull request #22 from PM2-IT21bWIN-ruiz-mach-krea/fix_participanFormular_and_placesFormular changed ParticipantFormular to change existing objects and don't repl…	2022-05-12 11:39:16 +02:00
schrom01	db51f2f3cd	implemented functionality to drawLines	2022-05-11 17:42:36 +02:00
schrom01	7f723fd763	implemented functionality to activate treeview	2022-05-11 16:21:38 +02:00
schrom01	b51a585167	added functionality to autosave result and place if changed.	2022-05-08 22:13:03 +02:00
schrom01	53ffa90c69	changed height of games.	2022-05-08 20:32:23 +02:00
schrom01	a44227b3f6	fixed spacing between games in GameSchedule	2022-05-08 20:20:41 +02:00
schrom01	38d1708a25	changed Alignment of VBox to center in TournamentSchedule	2022-05-08 17:28:41 +02:00
schrom01	afab6dbee3	refactoring of GameSchedule and button "close Tournament" added. added "informListener()" to method refreshParticipants in GameDecorator.java to be sure the new participants are saved in file.	2022-05-07 16:43:46 +02:00
schrom01	89e72a1592	solved Problem "points and places of games are not saved in file."	2022-05-07 15:45:43 +02:00
schrom01	5e88960c8a	extracted Method loadGameTree to FactoryDecorator.java	2022-05-07 15:34:08 +02:00
schrom01	923be52610	refactoring of GameController.java to load content only if previous games are edited.	2022-05-07 15:23:26 +02:00
schrom01	62df1db34b	refactoring of GameController.java to do it the same way as the other controllers.	2022-05-07 12:51:14 +02:00
schrom01	ecde0e6345	fixed Number of Games. #21	2022-05-07 12:32:18 +02:00
schrom01	4d193abb64	changed GameDecorator.java to show full name of players.	2022-05-07 12:17:50 +02:00
schrom01	3d13dbcb45	changed ParticipantFormular to change existing objects and don't replace them. changed ParticipantFormular and PlacesFormular to clear textfields after saving. solved #19	2022-05-07 11:53:10 +02:00
Andrin Fassbind	de728745f6	list all games in gameschedule prevent nullpointer exception for empty games	2022-05-06 19:26:34 +02:00
Andrin Fassbind	e5dc6a913a	make createTournament create all future games with null object for participant	2022-05-06 19:12:14 +02:00
Andrin Fassbind	4dc7db7590	made GameScheduleController and GameDecorator first gameround gets loaded in gamescheduleview	2022-05-06 18:40:13 +02:00
schrom01	9a3a9f3b53	removed Indexes from Game.java	2022-05-06 14:07:55 +02:00
schrom01	1b9e9c27a9	Merge remote-tracking branch 'origin/develope_Game_branch' into develope_Game_branch	2022-05-06 14:04:44 +02:00
schrom01	593bcdc872	added indexes to Game.java	2022-05-06 14:04:35 +02:00
Andrin Fassbind	4ef9f62124	update game with new id and new button to mark game as played	2022-05-06 13:36:49 +02:00
Andrin Fassbind	ebc0b64cb7	Create gameList in Tournament Create method to calc gameList and create random first round Started to develope view of gameSchedule	2022-05-06 13:34:22 +02:00
fassbandandGitHub Enterprise	47b53033c4	Merge pull request #18 from PM2-IT21bWIN-ruiz-mach-krea/LoggingFunction Logging function	2022-05-06 10:30:41 +02:00
fassbandandGitHub Enterprise	9bf6038ec1	Merge pull request #20 from PM2-IT21bWIN-ruiz-mach-krea/fix_participanFormular_and_placesFormular fixed participanFormular and placesFormular	2022-05-06 10:09:47 +02:00
schrom01	02456bc5bf	fixed participanFormular and placesFormular #19	2022-05-06 09:23:19 +02:00
leobr	035b096889	finished logging and improved logging in FileIO #17	2022-05-05 23:58:42 +02:00
Leonardo Brandenberger	1ff37de1a3	Initial logging draft	2022-05-05 23:03:48 +02:00
schrom01	f3495d28d6	fixed functionality Places Formular	2022-05-01 23:35:25 +02:00
schrom01	c323ab5759	fixed Merging problem	2022-05-01 22:50:07 +02:00
Roman SchenkandGitHub Enterprise	b2c23e158d	Merge pull request #16 from PM2-IT21bWIN-ruiz-mach-krea/FileIO FileIO completed including Java Doc and logging	2022-05-01 22:47:33 +02:00
schrom01	2f111cf1e4	implemented functionality of PlacesFormular	2022-05-01 22:43:41 +02:00
Roman SchenkandGitHub Enterprise	4ae7cd2e5a	Merge branch 'main' into FileIO	2022-05-01 22:42:02 +02:00
Leonardo Brandenberger	eb6d68e84f	FileIO completed including Java Doc and logging	2022-05-01 22:30:22 +02:00
Roman SchenkandGitHub Enterprise	594299f3b2	Merge pull request #13 from PM2-IT21bWIN-ruiz-mach-krea/Participant_List Participant list	2022-05-01 21:44:27 +02:00
Roman SchenkandGitHub Enterprise	7d30c6e4e7	Merge branch 'main' into Participant_List	2022-05-01 21:44:17 +02:00
Leonardo BrandenbergerandGitHub Enterprise	b359acfab4	Merge pull request #14 from PM2-IT21bWIN-ruiz-mach-krea/GameSchedule Game schedule	2022-05-01 21:36:16 +02:00
schrom01	0d482bfcac	implemented Functionality to save, edit and delete participants.	2022-05-01 21:26:32 +02:00
Andrin Fassbind	0db169a771	Added GameSchedule View when open tournament GameSchedule.fxml gets loaded	2022-05-01 20:26:33 +02:00
Roman SchenkandGitHub Enterprise	bd9dbef1de	Merge pull request #11 from PM2-IT21bWIN-ruiz-mach-krea/TournamentList Tournament list	2022-05-01 18:45:02 +02:00
schrom01	90fa3a9183	changed position of button.	2022-05-01 18:06:25 +02:00
schrom01	4cb743a21a	implemented functionality to save participants also in file.	2022-05-01 17:00:09 +02:00
schrom01	ff6f2bd94e	created Methods to show and add Players.	2022-05-01 15:18:30 +02:00
schrom01	b09929da19	added Participant List to Tournament.java	2022-05-01 14:22:01 +02:00
schrom01	678060ecc0	extracted Method delete Tournament in TournamentDecorator.java	2022-05-01 13:46:20 +02:00
schrom01	61b943b091	extracted Method open Tournament to Class FactoryDecorator.java	2022-05-01 13:39:54 +02:00
schrom01	9f005281af	created Class TournamentDecorator.java	2022-05-01 13:10:20 +02:00
schrom01	50f98b4ac1	added Type checking in Tournament.java	2022-05-01 12:33:14 +02:00
schrom01	80005d214d	created Class AlertDelete.java	2022-05-01 12:19:22 +02:00
schrom01	58b1692181	implemented Button and Method deleteTournament in Tournament List	2022-05-01 11:27:54 +02:00
schrom01	a3bd207610	refactored toString Method of class TournamentFile	2022-05-01 11:17:18 +02:00
schrom01	5034203409	extracted Method tournamentExists to FileIO.java	2022-05-01 11:10:21 +02:00
schrom01	e79a38c696	Merge branch 'FileIO' into TournamentList # Conflicts: # app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/FileIO.java	2022-05-01 10:56:22 +02:00
schrom01	672ad409ce	refactoring in FileIOTest.java	2022-05-01 10:54:21 +02:00
schrom01	e8e64d435c	added Method deleteTournament but not implemented yet in FileIO.java added Test Methods for deleteTournament.	2022-05-01 10:49:29 +02:00
schrom01	171cf7ef4e	implemented functionality to add new Tournament	2022-05-01 10:27:21 +02:00
schrom01	fd2e775c94	cleanCode fixes.	2022-04-30 18:22:06 +02:00
schrom01	71d13314f4	Solved Problems with Filenames ParticipantFormularController.java and TournamentListController.java	2022-04-30 18:17:01 +02:00
Roman SchenkandGitHub Enterprise	2ce93cbf9b	Merge pull request #8 from PM2-IT21bWIN-ruiz-mach-krea/fxml Fxml and Factory	2022-04-30 18:09:54 +02:00
Roman SchenkandGitHub Enterprise	5660f85165	Delete .gradle directory	2022-04-30 17:57:29 +02:00
Roman SchenkandGitHub Enterprise	c58fae060a	Delete .idea directory	2022-04-30 17:56:40 +02:00