Merge pull request 'do not recreate docker runner group and user' (!84) from do-no-recreate-group-and-user into develop

Reviewed-on: #84

.env.example

@@ -1,3 +1,5 @@
+APP_NAME=MapGuesser
+APP_URL=mapguesser.dev
 DEV=1
 DB_HOST=mariadb
 DB_USER=mapguesser
@@ -6,8 +8,19 @@ DB_NAME=mapguesser
 GOOGLE_MAPS_SERVER_API_KEY=your_google_maps_server_api_key
 GOOGLE_MAPS_JS_API_KEY=your_google_maps_js_api_key
 LEAFLET_TILESERVER_URL=a_leaflet_compatible_tileserver_url
+LEAFLET_TILESERVER_SUBDOMAINS=list_of_subdomains_for_the_tileserver_without_separators
 LEAFLET_TILESERVER_ATTRIBUTION=attribution_to_be_shown_for_tiles
 STATIC_ROOT=/static
 MAIL_FROM=mapguesser@mapguesser-dev.ch
 MAIL_HOST=mail
 MAIL_PORT=2500
+GOOGLE_OAUTH_CLIENT_ID=your_google_oauth_client_id
+GOOGLE_OAUTH_CLIENT_SECRET=your_google_oauth_client_secret
+GOOGLE_ANALITICS_ID=your_google_analytics_id
+MULTI_INTERNAL_HOST=multi
+MULTI_INTERNAL_PORT=5000
+MULTI_WS_URL=mapguesser-dev.ch:8090
+MULTI_WS_PORT=8090
+ENABLE_GAME_FOR_GUESTS=0
+RECAPTCHA_SITEKEY=your_recaptcha_sitekey
+RECAPTCHA_SECRET=your_recaptcha_secret

.gitignore

@@ -1,3 +1,4 @@
 .env
 installed
 vendor
+node_modules

.vscode/launch.json

@@ -9,6 +9,14 @@
             "pathMappings": {
                 "/var/www/mapguesser": "${workspaceRoot}",
             }
+        },
+        {
+            "name": "Listen for NodeJS Inspector in Docker",
+            "type": "node",
+            "request": "attach",
+            "port": 9229,
+            "localRoot": "${workspaceFolder}",
+            "remoteRoot": "/var/www/mapguesser"
         }
     ]
 }

Jenkinsfile

@@ -0,0 +1,106 @@
+pipeline {
+    agent {
+        node {
+            label 'mapguesser'
+            customWorkspace 'workspace/mapguesser'
+        }
+    }
+
+    stages {
+        stage('Install composer') {
+            environment {
+                COMPOSER_HOME="${WORKSPACE}/.composer"
+            }
+            agent {
+                dockerfile {
+                    filename 'docker/Dockerfile'
+                    dir '.'
+                    additionalBuildArgs '--target mapg_base'
+                    reuseNode true
+                }
+            }
+            steps {
+                sh 'composer install'
+            }
+        }
+
+        stage('Unit Testing') {
+            agent {
+                dockerfile {
+                    filename 'docker/Dockerfile'
+                    dir '.'
+                    additionalBuildArgs '--target mapg_base'
+                    reuseNode true
+                }
+            }
+            steps {
+                sh 'vendor/bin/phpunit --log-junit unit_test_results.xml --testdox tests'
+            }
+            post {
+                always {
+                    archiveArtifacts 'unit_test_results.xml'
+                }
+            }
+        }
+
+        stage('Static Code Analysis') {
+            agent {
+                dockerfile {
+                    filename 'docker/Dockerfile'
+                    dir '.'
+                    additionalBuildArgs '--target mapg_base'
+                    reuseNode true
+                }
+            }
+            steps {
+                sh 'php -d memory_limit=1G vendor/bin/phpstan analyse -c phpstan.neon --error-format=prettyJson > static_code_analysis_results.json'
+            }
+            post {
+                always {
+                    archiveArtifacts 'static_code_analysis_results.json'
+                }
+            }
+        }
+
+        stage('Prepare Docker release') {
+            environment {
+                COMPOSER_HOME="${WORKSPACE}/.composer"
+                npm_config_cache="${WORKSPACE}/.npm"
+            }
+            agent {
+                dockerfile {
+                    filename 'docker/Dockerfile'
+                    dir '.'
+                    additionalBuildArgs '--target mapg_base'
+                    reuseNode true
+                }
+            }
+            steps {
+                script {
+                    sh script: 'git clean -ffdx', label: 'Clean repository'
+                    env.VERSION = sh(script: 'git describe --tags --always --match "Release_*" HEAD', returnStdout: true).trim()
+                    sh script: 'docker/scripts/release.sh', label: 'Release script'
+                    sh script: "rm -rf ${env.COMPOSER_HOME} ${env.npm_config_cache}"
+                }
+            }
+        }
+
+        stage('Release Docker image') {
+            steps {
+                script {
+                    withDockerRegistry([credentialsId: 'gitea-system-user', url: 'https://git.esoko.eu/']) {
+                        sh script: 'docker buildx create --use --bootstrap --platform=linux/arm64,linux/amd64 --name multi-platform-builder'
+                        sh script: """docker buildx build \
+                                        --platform linux/amd64,linux/arm64 \
+                                        -f docker/Dockerfile \
+                                        --target mapg_release \
+                                        -t git.esoko.eu/esoko/mapguesser:${env.VERSION} \
+                                        --push \
+                                        .""",
+                           label: 'Build Docker image'
+                    }
+                }
+            }
+        }
+    }
+}

README.md

@@ -1,5 +1,105 @@
 # MapGuesser
 
-This is the MapGuesser Application project.
+[![Build Status](https://ci.esoko.eu/job/mapguesser/job/develop/badge/icon)](https://ci.esoko.eu/job/mapguesser/job/develop/)
 
-License: GNU AGPL 3.0
+This is the MapGuesser Application project. This is a game about guessing where you are based on a street view panorama - inspired by existing applications.
+
+## Installation
+
+### Set environment variables
+
+The `.env` file contains several environment variables that are needed by the application to work properly. These should be configured for your environment. Check `.env.example` for reference.
+
+**Important: `DEV` should NOT be set for production! See section Development if you want to use the application in development mode.**
+
+#### API keys
+
+**You should set the API keys that enable playing the game. Without these API keys the application cannot work well. To get Google API keys visit this page: https://console.developers.google.com/**
+
+Required Google APIs:
+* **Maps JavaScript API**: for the interactive maps and street views
+* **Maps Static API**: for the static map images
+* **Street View Static API**: for the backend metadata requests
+
+Required API keys:
+* **GOOGLE_MAPS_SERVER_API_KEY**: this it used by the backend and should have access to **Street View Static API**
+* **GOOGLE_MAPS_JS_API_KEY**: this is used by the frontend and should have access to **Maps JavaScript API** and **Maps Static API**
+
+Additionally, a tile provider is also needed for map editor. This should be configured by `LEAFLET_TILESERVER_URL`, `LEAFLET_TILESERVER_SUBDOMAINS` and `LEAFLET_TILESERVER_ATTRIBUTION`. You can find some providers here: https://wiki.openstreetmap.org/wiki/Tile_servers. OpenStreetMap's tile server is fine for testing.
+Example:
+```
+LEAFLET_TILESERVER_URL=https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png
+LEAFLET_TILESERVER_SUBDOMAINS=abc
+LEAFLET_TILESERVER_ATTRIBUTION="&copy; <a href=\"https://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors"
+```
+
+### Docker Compose
+
+Create a `docker-compose.yml` file. The example code below assumes that `.env` is placed in the same folder.
+
+```yml
+version: '3'
+services:
+    app:
+        image: git.esoko.eu/esoko/mapguesser:latest
+        depends_on:
+            mariadb:
+                condition: service_healthy
+        ports:
+            - 80:80
+            - 8090:8090
+        volumes:
+            - .env:/var/www/mapguesser/.env
+    mariadb:
+        image: mariadb:10.3
+        volumes:
+            - mysql:/var/lib/mysql
+        environment:
+            MYSQL_ROOT_PASSWORD: 'root'
+            MYSQL_DATABASE: 'mapguesser'
+            MYSQL_USER: 'mapguesser'
+            MYSQL_PASSWORD: 'mapguesser'
+        healthcheck:
+            test: ["CMD-SHELL", "mysqladmin -u $$MYSQL_USER -p$$MYSQL_PASSWORD ping -h localhost || exit 1"]
+            start_period: 5s
+            start_interval: 1s
+            interval: 5s
+            timeout: 5s
+            retries: 5
+volumes:
+    mysql:
+
+```
+
+Execute the following command:
+```bash
+docker compose up -d
+```
+
+
+**And you are done!** The application is ready to use. You can create the first administrative user with the following command after attaching to the `app` container:
+
+```
+./mapg user:add EMAIL USERNAME PASSWORD admin
+```
+
+## Development
+
+### Set environment variables
+
+`.env.example` should be copied to `.env` into the repo root. Only the variables for external dependencies (API keys, map attribution, etc.) should be adapted in. All other variables (for DB connection, static root, mailing, multiplayer, etc.) are fine with the default value. **`DEV=1` should be set for development!**
+
+### Docker Compose
+
+Execute the following command from the repo root:
+```bash
+docker compose up -d
+```
+
+**And you are done!** You can reach the application on http://localhost. The mails that are sent by the application can be found on http://localhost:8080. If needed, the database server can be directly reached on localhost:3306, or you can use Adminer web interface on http://localhost:9090
+
+You might have to attach to the `app` container, e.g. for creating users, `composer update`, etc.
+
+---
+
+*License: **GNU AGPL 3.0**. Full license text can be found in file `LICENSE`.*

bitbucket-pipelines.yml

@@ -0,0 +1,26 @@
+image: php:7.4.7-cli-buster
+
+pipelines:
+    default:
+        - step:
+              name: Unit Testing
+              caches:
+                  - composer
+              artifacts:
+                  - unit_test_results.xml
+              script:
+                  - apt-get update && apt-get install -y unzip
+                  - curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
+                  - composer install
+                  - vendor/bin/phpunit --log-junit unit_test_results.xml --testdox tests
+        - step:
+              name: Static Code Analysis
+              caches:
+                  - composer
+              artifacts:
+                  - static_code_analysis_results.json
+              script:
+                  - apt-get update && apt-get install -y unzip
+                  - curl -sS https://getcomposer.org/installer | php -- --install-dir=/usr/local/bin --filename=composer
+                  - composer install
+                  - php -d memory_limit=1G vendor/bin/phpstan analyse -c phpstan.neon --error-format=prettyJson > static_code_analysis_results.json

cache/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

composer.json

@@ -3,12 +3,19 @@
   "type": "project",
   "description": "MapGuesser Application",
   "license": "GNU GPL 3.0",
+  "repositories": [
+    {
+        "url": "https://git.esoko.eu/esoko/soko-web.git",
+        "type": "git"
+    }
+  ],
   "require": {
-    "vlucas/phpdotenv": "^4.1",
-    "symfony/console": "^5.1",
-    "phpmailer/phpmailer": "^6.1"
+    "esoko/soko-web": "0.15"
+  },
+  "require-dev": {
+    "phpunit/phpunit": "^10.3",
+    "phpstan/phpstan": "^1.10"
   },
-  "require-dev": {},
   "autoload": {
     "psr-4": {
       "MapGuesser\\": "src"

database/mapguesser.sql

@@ -15,6 +15,14 @@ CREATE TABLE `maps` (
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
 
 
+CREATE TABLE `migrations` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `migration` varchar(255) NOT NULL,
+  `type` enum('structure', 'data') NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
+
+
 DROP TABLE IF EXISTS `places`;
 CREATE TABLE `places` (
   `id` int(10) unsigned NOT NULL AUTO_INCREMENT,

database/migrations/data/20200602_2306_migrations.php

@@ -1 +0,0 @@
-<?php //empty on purpose

database/migrations/data/20200612_2124_map_area.php

@@ -1,8 +1,8 @@
 <?php
 
-use MapGuesser\Database\Query\Modify;
-use MapGuesser\Database\Query\Select;
-use MapGuesser\Interfaces\Database\IResultSet;
+use SokoWeb\Database\Query\Modify;
+use SokoWeb\Database\Query\Select;
+use SokoWeb\Interfaces\Database\IResultSet;
 use MapGuesser\Util\Geo\Bounds;
 
 $select = new Select(\Container::$dbConnection, 'maps');

database/migrations/data/20200614_1328_user_confirmation.php

@@ -1,8 +1,8 @@
 <?php
 
-use MapGuesser\Database\Query\Modify;
-use MapGuesser\Database\Query\Select;
-use MapGuesser\Interfaces\Database\IResultSet;
+use SokoWeb\Database\Query\Modify;
+use SokoWeb\Database\Query\Select;
+use SokoWeb\Interfaces\Database\IResultSet;
 
 $select = new Select(\Container::$dbConnection, 'users');
 $select->columns(['id']);

database/migrations/data/20230923_1905_username.php

@@ -0,0 +1,20 @@
+<?php
+
+use MapGuesser\PersistentData\Model\User;
+use MapGuesser\Repository\UserRepository;
+use MapGuesser\Util\UsernameGenerator;
+use SokoWeb\Database\Query\Select;
+
+$select = new Select(Container::$dbConnection);
+$users = Container::$persistentDataManager->selectMultipleFromDb($select, User::class);
+$userRepository = new UserRepository();
+$usernameGenerator = new UsernameGenerator();
+
+foreach ($users as $user) {
+    do {
+        $username = $usernameGenerator->generate();
+    } while ($userRepository->getByUsername($username));
+
+    $user->setUsername($username);
+    Container::$persistentDataManager->saveToDb($user);
+}

database/migrations/structure/20200602_2306_migrations.sql

@@ -1,6 +0,0 @@
-CREATE TABLE `migrations` (
-  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
-  `migration` varchar(255) NOT NULL,
-  `type` enum('structure', 'data') NOT NULL,
-  PRIMARY KEY (`id`)
-) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

database/migrations/structure/20200620_2113_google_login.sql

@@ -0,0 +1,8 @@
+ALTER TABLE
+  `users`
+ADD
+  `google_sub` varchar(255) CHARACTER SET ascii COLLATE ascii_bin NULL DEFAULT NULL,
+ADD
+  UNIQUE `google_sub` (`google_sub`),
+MODIFY
+  `password` varchar(60) NULL DEFAULT NULL;

database/migrations/structure/20200704_0005_pov_for_places.sql

@@ -0,0 +1,8 @@
+ALTER TABLE
+  `places`
+ADD
+  `pov_heading` decimal(6, 3) NOT NULL DEFAULT 0.0,
+ADD
+  `pov_pitch` decimal(5, 3) NOT NULL DEFAULT 0.0,
+ADD
+  `pov_zoom` decimal(5, 4) NOT NULL DEFAULT 0.0;

database/migrations/structure/20200704_1954_password_forgotten.sql

@@ -0,0 +1,10 @@
+CREATE TABLE `user_password_resetters` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `user_id` int(10) unsigned NOT NULL,
+  `token` varchar(32) CHARACTER SET ascii NOT NULL,
+  `expires` timestamp NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `user_id` (`user_id`),
+  KEY `token` (`token`),
+  CONSTRAINT `user_password_resetters_user_id` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

database/migrations/structure/20200705_0118_resend_activation.sql

@@ -0,0 +1,5 @@
+UPDATE `user_confirmations` SET token=SUBSTRING(token, 1, 32);
+
+ALTER TABLE `user_confirmations`
+  ADD `last_sent` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  MODIFY `token` varchar(32) CHARACTER SET ascii NOT NULL;

database/migrations/structure/20200705_0218_fix_timestamp_onupdate.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `sessions`
+  MODIFY `updated` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP;

database/migrations/structure/20200705_0219_redefine_tokens.sql

@@ -0,0 +1,4 @@
+UPDATE `sessions` SET id=SUBSTRING(id, 1, 32);
+
+ALTER TABLE `sessions`
+  MODIFY `id` varchar(32) CHARACTER SET ascii NOT NULL;

database/migrations/structure/20200706_1236_user_created.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `users`
+  ADD `created` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP;

database/migrations/structure/20210318_2136_multiplayer.sql

@@ -0,0 +1,9 @@
+CREATE TABLE `multi_rooms` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `room_id` varchar(6) NOT NULL,
+  `state` text NOT NULL,
+  `members` text NOT NULL,
+  `updated` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `room_id` (`room_id`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

database/migrations/structure/20210503_1040_user_played_place.sql

@@ -0,0 +1,12 @@
+CREATE TABLE `user_played_place` (
+    `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+    `user_id` int(10) unsigned NOT NULL,
+    `place_id` int(10) unsigned NOT NULL,
+    `last_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    `occurrences` int(10) NOT NULL DEFAULT 1,
+    PRIMARY KEY(`id`),
+    KEY `user_id` (`user_id`),
+    KEY `place_id` (`place_id`),
+    CONSTRAINT `user_played_place_user_id` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`),
+    CONSTRAINT `user_played_place_place_id` FOREIGN KEY (`place_id`) REFERENCES `places` (`id`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

database/migrations/structure/20210510_2000_challenge.sql

@@ -0,0 +1,54 @@
+CREATE TABLE `challenges` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `token` int(10) unsigned NOT NULL,
+  `time_limit` int(10) unsigned,
+  `time_limit_type` enum('game', 'round') NOT NULL DEFAULT 'game',
+  `no_move` tinyint(1) NOT NULL DEFAULT 0,
+  `no_pan` tinyint(1) NOT NULL DEFAULT 0,
+  `no_zoom` tinyint(1) NOT NULL DEFAULT 0,
+  `created` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
+
+CREATE TABLE `user_in_challenge` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `user_id` int(10) unsigned NOT NULL,
+  `challenge_id` int(10) unsigned NOT NULL,
+  `current_round` smallint(5) signed NOT NULL DEFAULT 0,
+  `time_left` int(10) unsigned,
+  `is_owner` tinyint(1) NOT NULL DEFAULT 0,
+  PRIMARY KEY (`id`),
+  KEY `user_id` (`user_id`),
+  KEY `challenge_id` (`challenge_id`),
+  CONSTRAINT `user_in_challenge_user_id` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`),
+  CONSTRAINT `user_in_challenge_challenge_id` FOREIGN KEY (`challenge_id`) REFERENCES `challenges` (`id`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
+
+CREATE TABLE `place_in_challenge` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `place_id` int(10) unsigned NOT NULL,
+  `challenge_id` int(10) unsigned NOT NULL,
+  `round` smallint(5) unsigned NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `place_id` (`place_id`),
+  KEY `challenge_id` (`challenge_id`),
+  CONSTRAINT `place_in_challenge_place_id` FOREIGN KEY (`place_id`) REFERENCES `places` (`id`),
+  CONSTRAINT `place_in_challenge_challenge_id` FOREIGN KEY (`challenge_id`) REFERENCES `challenges` (`id`),
+  CONSTRAINT `unique_order_in_challenge` UNIQUE (`round`, `challenge_id`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;
+
+CREATE TABLE `guesses` (
+  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `user_id` int(10) unsigned NOT NULL,
+  `place_in_challenge_id` int(10) unsigned NOT NULL,
+  `lat` decimal(8,6) NOT NULL,
+  `lng` decimal(9,6) NOT NULL,
+  `score` int(10) NOT NULL,
+  `distance` int(10) NOT NULL,
+  `time_spent` int(10),
+  PRIMARY KEY (`id`),
+  KEY `user_id` (`user_id`),
+  KEY `place_in_challenge_id` (`place_in_challenge_id`),
+  CONSTRAINT `guesses_user_id` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`),
+  CONSTRAINT `guesses_place_in_challenge_id` FOREIGN KEY (`place_in_challenge_id`) REFERENCES `place_in_challenge` (`id`)
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

database/migrations/structure/20220526_1315_unlisted_maps.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `maps`
+  ADD `unlisted` TINYINT(1) NOT NULL DEFAULT 0;

database/migrations/structure/20230923_1905_username.sql

@@ -0,0 +1,3 @@
+ALTER TABLE `users`
+  ADD `username` VARCHAR(255) CHARACTER SET ascii COLLATE ascii_bin DEFAULT NULL AFTER `email`,
+  ADD UNIQUE `username` (`username`);

docker-compose.yml

@@ -1,16 +1,25 @@
 version: '3'
 services:
     app:
-        build: ./docker
+        build:
+            context: .
+            dockerfile: docker/Dockerfile
+            target: mapg_dev
+        depends_on:
+            mariadb:
+                condition: service_healthy
         ports:
             - 80:80
+            - 5000:5000
+            - 8090:8090
+            - 9229:9229
         volumes:
             - .:/var/www/mapguesser
-        links:
-            - 'mariadb'
-            - 'mail'
+        working_dir: /var/www/mapguesser
     mariadb:
-        image: mariadb:10.1
+        image: mariadb:10.3
+        ports:
+            - 3306:3306
         volumes:
             - mysql:/var/lib/mysql
         environment:
@@ -18,6 +27,19 @@ services:
             MYSQL_DATABASE: 'mapguesser'
             MYSQL_USER: 'mapguesser'
             MYSQL_PASSWORD: 'mapguesser'
+        healthcheck:
+            test: ["CMD-SHELL", "mysqladmin -u $$MYSQL_USER -p$$MYSQL_PASSWORD ping -h localhost || exit 1"]
+            start_period: 5s
+            start_interval: 1s
+            interval: 5s
+            timeout: 5s
+            retries: 5
+    adminer:
+        image: adminer:4.8.1-standalone
+        ports:
+        - 9090:8080
+        environment:
+            - ADMINER_DEFAULT_SERVER=mariadb
     mail:
         image: marcopas/docker-mailslurper:latest
         ports:

docker/Dockerfile

@@ -1,30 +1,44 @@
-FROM ubuntu:focal
+FROM ubuntu:22.04 AS mapg_base
 
 ENV DEBIAN_FRONTEND noninteractive
 
-# Install Nginx, PHP and further necessary packages
-RUN apt update --fix-missing
-RUN apt install -y curl git mariadb-client nginx \
-    php-apcu php-xdebug php7.4-cli php7.4-curl php7.4-fpm php7.4-mbstring php7.4-mysql php7.4-zip
+RUN apt update --fix-missing && apt install -y sudo curl git unzip mariadb-client nginx \
+    php-apcu php8.1-cli php8.1-curl php8.1-fpm php8.1-mbstring php8.1-mysql php8.1-zip php8.1-xml
 
-# Configure Nginx with PHP
 RUN mkdir -p /run/php
-COPY configs/nginx.conf /etc/nginx/sites-available/default
-RUN echo "xdebug.remote_enable = 1" >> /etc/php/7.4/mods-available/xdebug.ini
-RUN echo "xdebug.remote_autostart = 1" >> /etc/php/7.4/mods-available/xdebug.ini
-RUN echo "xdebug.remote_connect_back = 1" >> /etc/php/7.4/mods-available/xdebug.ini
+COPY docker/configs/nginx.conf /etc/nginx/sites-available/default
 
-# Install Composer
-COPY scripts/install-composer.sh install-composer.sh
+COPY docker/scripts/install-composer.sh install-composer.sh
 RUN ./install-composer.sh
 
-# Install Node.js and required packages
-RUN curl -sL https://deb.nodesource.com/setup_14.x | bash -
-RUN apt install -y nodejs
-RUN npm install -g uglify-js clean-css-cli svgo
+COPY docker/scripts/install-nodejs.sh install-nodejs.sh
+RUN ./install-nodejs.sh
+RUN npm install -g uglify-js clean-css-cli svgo yarn
+
+
+FROM mapg_base AS mapg_dev
+
+RUN apt update --fix-missing && apt install -y php-xdebug
+
+RUN echo "xdebug.remote_enable = 1" >> /etc/php/8.1/mods-available/xdebug.ini &&\
+    echo "xdebug.remote_autostart = 1" >> /etc/php/8.1/mods-available/xdebug.ini &&\
+    echo "xdebug.remote_connect_back = 1" >> /etc/php/8.1/mods-available/xdebug.ini
 
 EXPOSE 80
-VOLUME /var/www/mapguesser
-WORKDIR /var/www/mapguesser
+EXPOSE 5000
+EXPOSE 8090
+EXPOSE 9229
+ENTRYPOINT docker/scripts/entry-point-dev.sh
 
-ENTRYPOINT /usr/sbin/php-fpm7.4 -F & /usr/sbin/nginx -g 'daemon off;'
+
+FROM mapg_base AS mapg_release
+
+RUN apt update --fix-missing && apt install -y cron
+
+WORKDIR /var/www/mapguesser
+COPY ./ /var/www/mapguesser
+RUN rm -rf /var/www/mapguesser/.git
+
+EXPOSE 80
+EXPOSE 8090
+ENTRYPOINT docker/scripts/entry-point.sh

docker/configs/nginx.conf

@@ -1,11 +1,15 @@
+map $http_x_forwarded_proto $forwarded_scheme {
+        default $scheme;
+        http http;
+        https https;
+}
+
 server {
         listen 80 default_server;
         listen [::]:80 default_server;
 
         root /var/www/mapguesser/public;
-
         index index.php index.html index.htm index.nginx-debian.html;
-
         server_name mapguesser-dev.ch;
 
         location / {
@@ -14,7 +18,8 @@ server {
 
         location ~ \.php$ {
                 include snippets/fastcgi-php.conf;
-                fastcgi_pass unix:/var/run/php/php7.4-fpm.sock;
+                fastcgi_pass unix:/var/run/php/php8.1-fpm.sock;
+                fastcgi_param REQUEST_SCHEME $forwarded_scheme;
         }
 
         location ~ /\.ht {

docker/scripts/cron

@@ -0,0 +1 @@
+0 * * * * /var/www/mapguesser/mapg db:maintain

docker/scripts/entry-point-dev.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+set -e
+
+echo "Installing Composer packages..."
+if [ -f .env ]; then
+    composer install
+else
+    composer create-project
+fi
+
+echo "Installing NPM packages..."
+(cd multi && npm install)
+
+echo "Installing Yarn packages..."
+(cd public/static && yarn install)
+
+echo "Migrating DB..."
+./mapg db:migrate
+
+echo "Set runner user based on owner of .env..."
+if ! getent group mapg; then
+    USER_GID=$(stat -c "%g" .env)
+    groupadd --gid $USER_GID mapg
+fi
+if ! id -u mapg; then
+    USER_UID=$(stat -c "%u" .env)
+    useradd --uid $USER_UID --gid $USER_GID mapg
+fi
+sed -i -e "s/^user = .*$/user = mapg/g" -e "s/^group = .*$/group = mapg/g" /etc/php/8.1/fpm/pool.d/www.conf
+
+set +e
+
+/usr/sbin/php-fpm8.1 -F &
+/usr/sbin/nginx -g 'daemon off;' &
+sudo -u mapg -g mapg /usr/bin/node --inspect=0.0.0.0:9229 multi &
+
+wait -n
+
+exit $?

docker/scripts/entry-point.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+set -e
+
+echo "Migrating DB..."
+./mapg db:migrate
+
+echo "Installing crontab..."
+/usr/bin/crontab docker/scripts/cron
+
+echo "Set runner user based on owner of .env..."
+if ! getent group mapg; then
+    USER_GID=$(stat -c "%g" .env)
+    groupadd --gid $USER_GID mapg
+fi
+if ! id -u mapg; then
+    USER_UID=$(stat -c "%u" .env)
+    useradd --uid $USER_UID --gid $USER_GID mapg
+fi
+chown mapg:mapg cache
+sed -i -e "s/^user = .*$/user = mapg/g" -e "s/^group = .*$/group = mapg/g" /etc/php/8.1/fpm/pool.d/www.conf
+
+set +e
+
+/usr/sbin/cron -f &
+/usr/sbin/php-fpm8.1 -F &
+/usr/sbin/nginx -g 'daemon off;' &
+sudo -u mapg -g mapg /usr/bin/node multi &
+
+wait -n
+
+exit $?

docker/scripts/install-nodejs.sh

@@ -0,0 +1,14 @@
+#!/bin/sh
+
+set -e
+
+apt update
+apt install -y ca-certificates curl gnupg
+mkdir -p /etc/apt/keyrings
+curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
+
+NODE_MAJOR=18
+echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list
+
+apt update
+apt install -y nodejs

docker/scripts/release.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+set -e
+
+echo "Installing Composer packages..."
+composer create-project --no-dev
+
+echo "Installing NPM packages..."
+(cd multi && npm install)
+
+echo "Installing Yarn packages..."
+(cd public/static && yarn install)
+
+echo "Updating version info..."
+VERSION=$(git describe --tags --always --match "Release_*" HEAD)
+REVISION=$(git rev-parse --short HEAD)
+REVISION_DATE=$(git show -s --format=%aI HEAD)
+sed -i -E "s/const VERSION = '(.*)';/const VERSION = '${VERSION}';/" main.php
+sed -i -E "s/const REVISION = '(.*)';/const REVISION = '${REVISION}';/" main.php
+sed -i -E "s/const REVISION_DATE = '(.*)';/const REVISION_DATE = '${REVISION_DATE}';/" main.php
+
+echo "Minifying JS, CSS and SVG files..."
+find public/static/js -type f -iname '*.js' -exec uglifyjs {} -c -m -o {} \;
+find public/static/css -type f -iname '*.css' -exec cleancss {} -o {} \;
+find public/static/img -type f -iname '*.svg' -exec svgo {} -o {} \;
+
+echo "Linking view files..."
+./mapg view:link
+
+rm .env

mail/password-reset.html

@@ -0,0 +1,13 @@
+Hi,
+<br><br>
+You recently requested password reset on {{APP_NAME}} with this email address ({{EMAIL}}).
+To reset the password to your account, please click on the following link:<br>
+<a href="{{RESET_LINK}}" title="Reset password">{{RESET_LINK}}</a>
+<br><br>
+You can reset your password with this link util {{EXPIRES}}.
+<br><br>
+If you did not requested password reset, no further action is required, your account is not touched.
+<br><br>
+Regards,<br>
+{{APP_NAME}}<br>
+<a href="{{BASE_URL}}" title="{{APP_NAME}}">{{BASE_URL}}</a>

mail/signup-noconfirm.html

@@ -0,0 +1,9 @@
+Hi,
+<br><br>
+You recently signed up on {{APP_NAME}} with this Google account ({{EMAIL}}).
+<br><br>
+Have fun on {{APP_NAME}}!
+<br><br>
+Regards,<br>
+{{APP_NAME}}<br>
+<a href="{{BASE_URL}}" title="{{APP_NAME}}">{{BASE_URL}}</a>

mail/signup.html

@@ -1,13 +1,18 @@
 Hi,
 <br><br>
-You recently signed up on MapGuesser with this email address ({{EMAIL}}). To activate your account, please click on the following link:<br>
+You recently signed up on {{APP_NAME}} with this email address ({{EMAIL}}).
+To activate your account, please click on the following link:<br>
 <a href="{{ACTIVATE_LINK}}" title="Account activation">{{ACTIVATE_LINK}}</a>
 <br><br>
-If you did not sign up on MapGuesser or changed your mind, no further action is required, your email address will be deleted soon.<br>
-However if you want to immediately delete it, please click on the following link:<br>
+You can activate your account until {{ACTIVATABLE_UNTIL}}.
+If you don't activate your account, your email address will be permanently deleted after this point of time.
+<br><br>
+If you did not sign up on {{APP_NAME}} or changed your mind, no further action is required.
+However if you want to immediately delete your email address, please click on the following link:<br>
 <a href="{{CANCEL_LINK}}" title="Sign up cancellation">{{CANCEL_LINK}}</a>
 <br><br>
-Have fun on MapGuesser!
+Have fun on {{APP_NAME}}!
 <br><br>
 Regards,<br>
-MapGuesser
+{{APP_NAME}}<br>
+<a href="{{BASE_URL}}" title="{{APP_NAME}}">{{BASE_URL}}</a>

main.php

@@ -1,5 +1,7 @@
 <?php
 
+define('SCRIPT_STARTED', hrtime(true));
+
 require 'vendor/autoload.php';
 
 const ROOT = __DIR__;
@@ -12,10 +14,12 @@ $dotenv->load();
 
 class Container
 {
-    static MapGuesser\Interfaces\Database\IConnection $dbConnection;
-    static MapGuesser\Routing\RouteCollection $routeCollection;
-    static \SessionHandlerInterface $sessionHandler;
-    static MapGuesser\Interfaces\Request\IRequest $request;
+    static SokoWeb\Interfaces\Database\IConnection $dbConnection;
+    static SokoWeb\Interfaces\PersistentData\IPersistentDataManager $persistentDataManager;
+    static SokoWeb\Interfaces\Routing\IRouteCollection $routeCollection;
+    static SokoWeb\Interfaces\Session\ISessionHandler $sessionHandler;
+    static SokoWeb\Interfaces\Request\IRequest $request;
 }
 
-Container::$dbConnection = new MapGuesser\Database\Mysql\Connection($_ENV['DB_HOST'], $_ENV['DB_USER'], $_ENV['DB_PASSWORD'], $_ENV['DB_NAME']);
+Container::$dbConnection = new SokoWeb\Database\Mysql\Connection($_ENV['DB_HOST'], $_ENV['DB_USER'], $_ENV['DB_PASSWORD'], $_ENV['DB_NAME']);
+Container::$persistentDataManager = new SokoWeb\PersistentData\PersistentDataManager(Container::$dbConnection);

mapg

@@ -5,7 +5,9 @@ require 'main.php';
 
 $app = new Symfony\Component\Console\Application('MapGuesser Console', '');
 
-$app->add(new MapGuesser\Cli\DatabaseMigration());
+$app->add(new MapGuesser\Cli\MigrateDatabaseCommand());
 $app->add(new MapGuesser\Cli\AddUserCommand());
+$app->add(new MapGuesser\Cli\LinkViewCommand());
+$app->add(new MapGuesser\Cli\MaintainDatabaseCommand());
 
 $app->run();

multi/index.js

@@ -0,0 +1,369 @@
+'use strict';
+
+process.title = 'mapguesser-multi';
+
+class MultiGame {
+    static ROUND_TIMEOUT_DEFAULT = 120000;
+    static ROUND_TIMEOUT_MINIMUM = 15000;
+    static ROUND_TIMEOUT_DIVIDER = 1.5;
+    static ROUND_TIMEOUT_OFFSET = 500;
+
+    constructor() {
+        this.rooms = new Map();
+    }
+
+    cleanupRooms() {
+        this.rooms.forEach(function (room, roomId) {
+            var lastValidDate = new Date(new Date().getTime() - 7 * 24 * 60 * 60 * 1000);
+
+            if (room.updated < lastValidDate) {
+                this.rooms.delete(roomId);
+            }
+        });
+    }
+
+    connectToRoom(roomId, token, connection) {
+        if (!this.rooms.has(roomId) || !this.rooms.get(roomId).members.has(token)) {
+            return;
+        }
+
+        var room = this.rooms.get(roomId)
+        var member = room.members.get(token);
+        member.connection = connection;
+
+        this._sendInitialData(room, member, token);
+    }
+
+    createRoom(roomId) {
+        this.rooms.set(roomId, { members: new Map(), rounds: [], currentRound: -1, updated: new Date() });
+
+        return { ok: true };
+    }
+
+    joinRoom(roomId, token, userName) {
+        if (!this.rooms.has(roomId)) {
+            return { error: 'room_not_found' };
+        }
+
+        var room = this.rooms.get(roomId);
+        room.updated = new Date();
+
+        if (room.members.has(token)) {
+            return { error: 'member_already_joined' };
+        }
+
+        var data = { userName: userName };
+        var self = this;
+        room.members.forEach(function (member) {
+            self._sendToMember(member, 'member_joined', data);
+        });
+
+        room.members.set(token, { userName: userName, connection: null });
+
+        return { ok: true };
+    }
+
+    startGame(roomId, places) {
+        if (!this.rooms.has(roomId)) {
+            return { error: 'room_not_found' };
+        }
+
+        var room = this.rooms.get(roomId);
+        room.updated = new Date();
+
+        var rounds = [];
+        places.forEach(function (place) {
+            rounds.push({
+                place: place,
+                results: new Map(),
+                timeout: MultiGame.ROUND_TIMEOUT_DEFAULT,
+                timeoutStarted: null,
+                timeoutHandler: null
+            })
+        });
+
+        room.rounds = rounds;
+
+        this.nextRound(roomId, 0);
+
+        return { ok: true };
+    }
+
+    guess(roomId, token, guessPosition, distance, score) {
+        if (!this.rooms.has(roomId)) {
+            return { error: 'room_not_found' };
+        }
+
+        var room = this.rooms.get(roomId);
+        room.updated = new Date();
+
+        var round = room.rounds[room.currentRound];
+        if (round.results.has(token)) {
+            return { error: 'already_guessed' };
+        }
+
+        var member = room.members.get(token);
+        var allResults = this._collectResultsInRound(room, round);
+
+        this._broadcastGuess(room, member.userName, guessPosition, distance, score);
+
+        round.results.set(token, { guessPosition: guessPosition, distance: distance, score: score });
+
+        this._setNewTimeout(room, round);
+
+        return { allResults: allResults };
+    }
+
+    nextRound(roomId, currentRound) {
+        if (!this.rooms.has(roomId)) {
+            return { error: 'room_not_found' };
+        }
+
+        var room = this.rooms.get(roomId);
+        room.updated = new Date();
+
+        room.currentRound = currentRound;
+
+        var round = room.rounds[room.currentRound];
+
+        round.timeoutStarted = new Date();
+        var self = this;
+        round.timeoutHandler = setTimeout(function () {
+            self._endRound(room, round);
+        }, round.timeout + MultiGame.ROUND_TIMEOUT_OFFSET);
+
+        var data = {};
+        data.place = { panoId: round.place.panoId, pov: round.place.pov };
+        data.timeout = round.timeout;
+
+        var self = this;
+        room.members.forEach(function (member) {
+            self._sendToMember(member, 'new_round', data);
+        });
+
+        return { ok: true };
+    }
+
+    _setNewTimeout(room, round) {
+        clearTimeout(round.timeoutHandler);
+
+        if (room.members.size === round.results.size) {
+            round.timeout = 0;
+            round.timeoutStarted = new Date();
+
+            this._endRound(room, round);
+        } else {
+            round.timeout = round.timeout - (new Date() - round.timeoutStarted);
+            if (round.timeout > MultiGame.ROUND_TIMEOUT_DIVIDER * MultiGame.ROUND_TIMEOUT_MINIMUM) {
+                round.timeout = Math.round(round.timeout / MultiGame.ROUND_TIMEOUT_DIVIDER);
+            } else if (round.timeout > MultiGame.ROUND_TIMEOUT_MINIMUM) {
+                round.timeout = MultiGame.ROUND_TIMEOUT_MINIMUM;
+            }
+            round.timeoutStarted = new Date();
+            var self = this;
+            round.timeoutHandler = setTimeout(function () {
+                self._endRound(room, round);
+            }, round.timeout + MultiGame.ROUND_TIMEOUT_OFFSET);
+
+            this._broadcastTimeout(room, round);
+        }
+    }
+
+    _endRound(room, round) {
+        var allResults = this._collectResultsInRound(room, round);
+        var self = this;
+        room.members.forEach(function (member, token) {
+            var result = { guessPosition: null, distance: null, score: 0 };
+
+            if (round.results.has(token)) {
+                result = round.results.get(token);
+            } else {
+                round.results.set(token, result);
+            }
+
+            var data = { position: round.place.position, result: result, allResults: allResults };
+            self._sendToMember(member, 'end_round', data);
+        });
+    }
+
+    _sendInitialData(room, member, token) {
+        var data = {};
+
+        if (room.currentRound >= 0) {
+            var round = room.rounds[room.currentRound];
+
+            data.place = round.place;
+            data.timeout = round.timeout - (new Date() - round.timeoutStarted);
+        }
+
+        data.history = [];
+        for (var i = 0; i <= room.currentRound; ++i) {
+            var round = room.rounds[i];
+
+            if (i === room.currentRound && !round.results.has(token)) {
+                continue;
+            }
+
+            var result = { guessPosition: null, distance: null, score: 0 };
+            var allResults = [];
+
+            round.results.forEach(function (currentResult, currentToken) {
+                if (token === currentToken) {
+                    result = currentResult;
+                    return;
+                }
+
+                allResults.push({ userName: room.members.get(currentToken).userName, guessPosition: currentResult.guessPosition, distance: currentResult.distance, score: currentResult.score });
+            });
+
+            data.history.push({
+                position: round.place.position,
+                result: result,
+                allResults: allResults
+            });
+        }
+
+        data.members = [];
+        room.members.forEach(function (currentMember) {
+            data.members.push({ userName: currentMember.userName, me: member === currentMember });
+        });
+
+        data.readyToContinue = room.currentRound >= 0 && room.members.size === room.rounds[room.currentRound].results.size
+
+        this._sendToMember(member, 'initialize', data);
+    }
+
+    _collectResultsInRound(room, round) {
+        var results = [];
+        round.results.forEach(function (result, token) {
+            results.push({
+                userName: room.members.get(token).userName,
+                guessPosition: result.guessPosition,
+                distance: result.distance,
+                score: result.score
+            });
+        });
+
+        return results;
+    }
+
+    _broadcastTimeout(room, round) {
+        var self = this;
+        room.members.forEach(function (member) {
+            self._sendToMember(member, 'timeout_changed', { timeout: round.timeout });
+        });
+    }
+
+    _broadcastGuess(room, userName, guessPosition, distance, score) {
+        var data = { userName: userName, guessPosition: guessPosition, distance: distance, score: score };
+        var round = room.rounds[room.currentRound];
+        var self = this;
+        room.members.forEach(function (member, token) {
+            if (!round.results.has(token)) {
+                return;
+            }
+
+            self._sendToMember(member, 'guess', data);
+        });
+    }
+
+    _sendToMember(member, type, data) {
+        if (!member.connection) {
+            return;
+        }
+
+        if (member.connection.readyState !== ws.OPEN) {
+            member.connection = null;
+            return;
+        }
+
+        member.connection.send(JSON.stringify({ type: type, data: data }));
+    }
+}
+
+require('dotenv').config();
+
+var
+    net = require('net'),
+    ws = require('ws');
+
+var multiGame = new MultiGame();
+
+//TODO: following should be in a separate class/function
+
+var tcpServer = net.createServer(function (socket) {
+    socket.on('data', function (data) {
+        try {
+            data = JSON.parse(data);
+        } catch (e) {
+            console.error('Cannot parse data: ' + data);
+            return;
+        }
+
+        var response;
+        switch (data.func) {
+            case 'create_room':
+                response = multiGame.createRoom(data.args.roomId);
+
+                break;
+
+            case 'join_room':
+                response = multiGame.joinRoom(data.args.roomId, data.args.token, data.args.userName);
+
+                break;
+
+            case 'start_game':
+                response = multiGame.startGame(data.args.roomId, data.args.places);
+
+                break
+
+            case 'guess':
+                response = multiGame.guess(data.args.roomId, data.args.token, data.args.guessPosition, data.args.distance, data.args.score);
+
+                break;
+
+            case 'next_round':
+                response = multiGame.nextRound(data.args.roomId, data.args.currentRound);
+
+                break;
+        }
+
+        socket.write(JSON.stringify(response));
+        socket.end();
+    });
+});
+tcpServer.on('listening', function () {
+    console.log('[INFO] TCP server started');
+});
+tcpServer.listen(process.env.MULTI_INTERNAL_PORT);
+
+var wsServer = new ws.Server({ port: process.env.MULTI_WS_PORT });
+wsServer.on('connection', function (connection, request) {
+    console.log('[INFO] New WS connection: ' + request.connection.remoteAddress);
+
+    connection.on('message', function (data) {
+        try {
+            data = JSON.parse(data);
+        } catch (e) {
+            console.error('Cannot parse data: ' + data);
+            return;
+        }
+
+        switch (data.func) {
+            case 'connect_to_room':
+                multiGame.connectToRoom(data.args.roomId, data.args.token, connection);
+                break;
+        }
+    });
+
+    connection.on('close', function () {
+        console.log('[INFO] WS connection ended: ' + request.connection.remoteAddress);
+    });
+});
+wsServer.on('listening', function () {
+    console.log('[INFO] WS server started');
+});
+
+setInterval(function () {
+    multiGame.cleanupRooms();
+}, 24 * 60 * 60 * 1000);

multi/package-lock.json

@@ -0,0 +1,43 @@
+{
+    "name": "mapguesser-multi",
+    "lockfileVersion": 3,
+    "requires": true,
+    "packages": {
+        "": {
+            "name": "mapguesser-multi",
+            "license": "GNU AGPL 3.0",
+            "dependencies": {
+                "dotenv": "^8.2.0",
+                "ws": "^7.4.4"
+            }
+        },
+        "node_modules/dotenv": {
+            "version": "8.2.0",
+            "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-8.2.0.tgz",
+            "integrity": "sha512-8sJ78ElpbDJBHNeBzUbUVLsqKdccaa/BXF1uPTw3GrvQTBgrQrtObr2mUrE38vzYd8cEv+m/JBfDLioYcfXoaw==",
+            "engines": {
+                "node": ">=8"
+            }
+        },
+        "node_modules/ws": {
+            "version": "7.4.4",
+            "resolved": "https://registry.npmjs.org/ws/-/ws-7.4.4.tgz",
+            "integrity": "sha512-Qm8k8ojNQIMx7S+Zp8u/uHOx7Qazv3Yv4q68MiWWWOJhiwG5W3x7iqmRtJo8xxrciZUY4vRxUTJCKuRnF28ZZw==",
+            "engines": {
+                "node": ">=8.3.0"
+            },
+            "peerDependencies": {
+                "bufferutil": "^4.0.1",
+                "utf-8-validate": "^5.0.2"
+            },
+            "peerDependenciesMeta": {
+                "bufferutil": {
+                    "optional": true
+                },
+                "utf-8-validate": {
+                    "optional": true
+                }
+            }
+        }
+    }
+}

multi/package.json

@@ -0,0 +1,13 @@
+{
+    "name": "mapguesser-multi",
+    "version": "",
+    "description": "MapGuesser Application - Multiplayer",
+    "main": "index.js",
+    "dependencies": {
+        "dotenv": "^8.2.0",
+        "ws": "^7.4.4"
+    },
+    "scripts": {},
+    "author": "Pőcze Bence and The MapGuesser Contributors <bence@pocze.ch>",
+    "license": "GNU AGPL 3.0"
+}

phpstan.neon

@@ -0,0 +1,9 @@
+parameters:
+    level: 5
+    checkMissingIterableValueType: false
+    paths:
+        - main.php
+        - mapg
+        - web.php
+        - src
+        - tests

public/index.php

@@ -1,51 +1,3 @@
 <?php
 
 require '../web.php';
-
-$method = strtolower($_SERVER['REQUEST_METHOD']);
-$url = substr($_SERVER['REQUEST_URI'], strlen('/'));
-if (($pos = strpos($url, '?')) !== false) {
-    $url = substr($url, 0, $pos);
-}
-$url = rawurldecode($url);
-
-$match = Container::$routeCollection->match($method, explode('/', $url));
-
-if ($match !== null) {
-    list($route, $params) = $match;
-
-    Container::$request->setParsedRouteParams($params);
-
-    $handler = $route->getHandler();
-    $controller = new $handler[0](Container::$request);
-
-    if ($controller instanceof MapGuesser\Interfaces\Authorization\ISecured) {
-        $authorized = $controller->authorize();
-    } else {
-        $authorized = true;
-    }
-
-    if ($method === 'post' && Container::$request->post('anti_csrf_token') !== Container::$request->session()->get('anti_csrf_token')) {
-        header('Content-Type: text/html; charset=UTF-8', true, 403);
-        echo json_encode(['error' => 'no_valid_anti_csrf_token']);
-        return;
-    }
-
-    if ($authorized) {
-        $response = call_user_func([$controller, $handler[1]]);
-
-        if ($response instanceof MapGuesser\Interfaces\Response\IContent) {
-            header('Content-Type: ' . $response->getContentType() . '; charset=UTF-8');
-            echo $response->render();
-
-            return;
-        } elseif ($response instanceof MapGuesser\Interfaces\Response\IRedirect) {
-            header('Location: ' . Container::$request->getBase() . '/' . $response->getUrl(), true, $response->getHttpCode());
-
-            return;
-        }
-    }
-}
-
-header('Content-Type: text/html; charset=UTF-8', true, 404);
-require ROOT . '/views/error/404.php';

public/static/css/game.css

@@ -1,17 +1,31 @@
 #panorama {
-    width: 100%;
-    height: calc(100% - 40px);
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    right: 0;
     z-index: 1;
 }
 
-#guessCover {
+#panoCover {
     position: absolute;
-    top: 40px;
+    top: 0;
     left: 0;
     bottom: 0;
     right: 0;
     background-color: #000000;
     opacity: 0.5;
+    z-index: 4;
+}
+
+#panningBlockerCover {
+    display: none;
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    right: 0;
+    opacity: 0;
     z-index: 3;
 }
 
@@ -19,7 +33,7 @@
     position: absolute;
     bottom: 30px;
     right: 20px;
-    z-index: 2;
+    z-index: 3;
 }
 
 #guess.result {
@@ -76,7 +90,7 @@
     line-height: 1;
 }
 
-#distanceInfo>p:nth-child(2), #scoreInfo>p:nth-child(2) {
+#distanceInfo>p:nth-child(2), #distanceInfo>p:nth-child(3), #scoreInfo>p:nth-child(2) {
     display: none;
 }
 
@@ -99,19 +113,111 @@
     display: none;
 }
 
+#startMultiGameButton {
+    display: none;
+}
+
+#players > p {
+    font-size: 14px;
+    font-weight: bold;
+}
+
+#countdown {
+    position: absolute;
+    top: 5px;
+    right: 5px;
+    height: 28px;
+    line-height: 28px;
+    padding: 0 8px;
+    background-color: #eeeeee;
+    border: solid 1px #555555;
+    border-radius: 3px;
+    opacity: 0.95;
+    z-index: 5;
+    visibility: hidden;
+}
+
+#countdown.yellow {
+    background-color: #f7c789;
+    border: solid 1px #e8a349;
+}
+
+#countdown.red {
+    background-color: #f7a5a5;
+    border: solid 1px #aa5e5e;
+}
+
+#countdown p {
+    font-size: 16px;
+    line-height: inherit;
+}
+
+#countdown.yellow p {
+    color: #9c4308;
+}
+
+#countdown.red p {
+    color: #701919;
+}
+
+#navigation {
+    z-index: 2;
+}
+
+#goToStart {
+    display: none;
+}
+
+#highscoresTable {
+    margin: 1em;
+    border-collapse: collapse;
+    width: 90%;
+}
+
+#highscoresTable td, #highscoresTable th {
+    border: 1px solid #ddd;
+    padding: 8px;
+}
+
+#highscoresTable tr:nth-child(even) {
+    background-color: #f2f2f2;
+}
+
+#highscoresTable tr:hover {
+    background-color: #ddd;
+}
+
+#highscoresTable th {
+    padding-top: 12px;
+    padding-bottom: 12px;
+    text-align: left;
+    background-color: #e8a349;
+    color: white;
+}
+
+#highscoresTable tr.ownPlayer {
+    font-weight: 500;
+}
+
+@media screen and (max-width: 899px) {
+    .hideOnNarrowScreen {
+        display: none;
+    }
+}
+
 @media screen and (max-width: 599px) {
     #mapName {
         display: none;
     }
     #showGuessButtonContainer {
         position: absolute;
-        left: 20px;
+        left: 65px;
         bottom: 30px;
         right: 20px;
         z-index: 2;
     }
     #guess {
-        top: 50px;
+        top: 10px;
         left: 20px;
         opacity: 0.95;
         visibility: hidden;
@@ -122,6 +228,10 @@
     #scoreBarBase {
         width: 100%;
     }
+    #navigation {
+        bottom: 25px;
+        left: 10px;
+    }
 }
 
 @media screen and (min-width: 600px) {
@@ -157,7 +267,7 @@
     #guess.result {
         width: initial;
         height: initial;
-        top: 50px;
+        top: 10px;
         left: 50px;
         right: 50px;
         bottom: 50px;
@@ -165,13 +275,17 @@
     #scoreBarBase {
         width: 60%;
     }
+    #navigation {
+        bottom: 50px;
+        left: 20px;
+    }
     @media screen and (max-height: 424px) {
         #guess {
-            top: 50px;
+            top: 10px;
             height: initial;
         }
         #guess.adapt:hover {
-            top: 50px;
+            top: 10px;
             height: initial;
         }
         #guess.result {
@@ -179,5 +293,9 @@
             right: 20px;
             bottom: 30px;
         }
+        #navigation {
+            bottom: 30px;
+            left: 10px;
+        }
     }
 }

public/static/css/map_editor.css

@@ -1,9 +1,20 @@
-#map {
-    width: 100%;
-    height: calc(100% - 40px);
+.map {
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    right: 0;
     z-index: 1;
 }
 
+#mapSelection img {
+    display: inline;
+    width: 1em;
+    height: 1em;
+    vertical-align: -0.15em;
+}
+
+/* modify the cursor for the Leaflet map */
 .leaflet-container {
     cursor: crosshair;
 }
@@ -16,6 +27,8 @@
 
 #noPano {
     display: flex;
+    justify-content: center;
+    align-items: center;
     position: absolute;
     z-index: 2;
     visibility: hidden;
@@ -23,12 +36,12 @@
 }
 
 #noPano>p {
-    margin: auto;
+    text-align: center;
 }
 
 #control {
     position: absolute;
-    top: 50px;
+    top: 10px;
     right: 10px;
     width: 125px;
     z-index: 3;
@@ -42,37 +55,49 @@
     visibility: hidden;
 }
 
+#overlayControl {
+    bottom: 20px;
+    right: 10px;
+    z-index: 3;
+}
+
 #deleteButton {
     display: none;
 }
 
 @media screen and (max-width: 999px) and (min-height: 600px) {
     #map.selected {
-        height: calc(50% - 20px);
+        height: 50%;
     }
     #panorama, #noPano {
         left: 0;
         bottom: 0;
         right: 0;
-        height: calc(50% - 20px);
+        height: 50%;
     }
     #placeControl {
-        top: calc(50% + 30px);
+        top: calc(50% + 10px);
+    }
+    .hideOnMobile {
+        display: none;
     }
 }
 
 @media screen and (min-width: 1000px), (max-height: 599px) {
     #map.selected {
+        top: 0;
+        bottom: 0;
+        left: 0;
         width: 50%;
     }
     #panorama, #noPano {
-        top: 40px;
+        top: 0;
         bottom: 0;
         right: 0;
         width: 50%;
     }
     #placeControl {
-        top: 50px;
+        top: 10px;
     }
     #modified.selected {
         right: calc(50% + 10px);

public/static/css/mapguesser.css

@@ -12,21 +12,30 @@ html, body {
     padding: 0;
 }
 
+body {
+    background-color: #cccccc;
+}
+
 button::-moz-focus-inner, input::-moz-focus-inner {
     padding: 0;
     border: 0;
 }
 
+/* to be compatible with browsers that don't know <main> */
+main {
+    display: block;
+}
+
 ::selection {
     background-color: #28a745;
     color: #ffffff;
 }
 
-p, h1, h2, input, textarea, select, button, a {
+p, h1, h2, h3, input, textarea, select, button, a, table, label {
     font-family: 'Roboto', sans-serif;
 }
 
-h1, h2 {
+h1, h2, h3 {
     font-weight: 500;
 }
 
@@ -42,11 +51,15 @@ h1>a:hover, h1>a:focus {
     text-decoration: none;
 }
 
-h2, div.header.small h1 {
+h2, header.small h1 {
     font-size: 24px;
 }
 
-p, h2 {
+h3 {
+    font-size: 18px;
+}
+
+p, h2, h3 {
     line-height: 150%;
 }
 
@@ -83,8 +96,8 @@ hr {
     font-weight: 500;
 }
 
-.small {
-    font-size: 12px;
+p.small, span.small {
+    font-size: 14px;
 }
 
 .justify {
@@ -107,6 +120,10 @@ hr {
     margin-right: 10px;
 }
 
+.center {
+    text-align: center;
+}
+
 .right {
     text-align: right;
 }
@@ -115,6 +132,7 @@ svg.inline, img.inline {
     display: inline;
     width: 1em;
     height: 1em;
+    margin-right: 0.3em;
     vertical-align: -0.15em;
 }
 
@@ -143,6 +161,27 @@ button, a.button {
     line-height: 35px;
 }
 
+button.small, div.inputWithButton>button {
+    font-size: 14px;
+    padding: 0 12px;
+    height: 32px;
+    line-height: 32px;
+}
+
+button.small {
+    height: 32px;
+    line-height: 32px;
+}
+
+div.inputWithButton>button {
+    border-radius: 2px;
+    height: 27px;
+    line-height: 27px;
+    width: 75px;
+    margin-left: -79px;
+    vertical-align: 2px;
+}
+
 button:enabled:hover, button:enabled:focus, a.button:hover, a.button:focus {
     background-color: #29457f;
     outline: none;
@@ -174,7 +213,7 @@ button.gray, a.button.gray {
     background-color: #808080;
 }
 
-button.gray:hover, button.gray:focus, a.button.gray:hover, a.button.gray:focus {
+button.gray:enabled:hover, button.gray:enabled:focus, a.button.gray:hover, a.button.gray:focus {
     background-color: #555555;
 }
 
@@ -182,7 +221,7 @@ button.red, a.button.red {
     background-color: #aa5e5e;
 }
 
-button.red:hover, button.red:focus, a.button.red:hover, a.button.red:focus {
+button.red:enabled:hover, button.red:enabled:focus, a.button.red:hover, a.button.red:focus {
     background-color: #7f2929;
 }
 
@@ -190,7 +229,7 @@ button.yellow, a.button.yellow {
     background-color: #e8a349;
 }
 
-button.yellow:hover, button.yellow:focus, a.button.yellow:hover, a.button.yellow:focus {
+button.yellow:enabled:hover, button.yellow:enabled:focus, a.button.yellow:hover, a.button.yellow:focus {
     background-color: #c37713;
 }
 
@@ -198,60 +237,97 @@ button.green, a.button.green {
     background-color: #28a745;
 }
 
-button.green:hover, button.green:focus, a.button.green:hover, a.button.green:focus {
+button.green:enabled:hover, button.green:enabled:focus, a.button.green:hover, a.button.green:focus {
     background-color: #1b7d31;
 }
 
-input, select, textarea {
+input.text, select, textarea {
     background-color: #f9fafb;
     border: solid #c8d2e1 1px;
     border-radius: 2px;
-    padding: 4px;
     box-sizing: border-box;
     font-size: 15px;
     font-weight: 300;
 }
 
+input.text, select {
+    height: 30px;
+    line-height: 30px;
+    padding: 0 5px;
+}
+
+input[type=checkbox], input[type=radio] {
+    margin-right: 0.5em;
+}
+
 textarea {
-    font-size: 13px;
+    padding: 5px;
     resize: none;
 }
 
-input.big, select.big, textarea.big {
-    padding: 5px;
+input.text.big, select.big, textarea.big, div.inputWithButton>input.text {
     font-size: 18px;
 }
 
+input.text.big, select.big, div.inputWithButton>input.text {
+    height: 35px;
+    line-height: 35px;
+    padding: 0 6px;
+}
+
+textarea.big {
+    padding: 6px;
+}
+
 input.fullWidth, select.fullWidth, textarea.fullWidth {
     display: block;
     width: 100%;
 }
 
-input:disabled, select:disabled, textarea:disabled {
+input.text:disabled, select:disabled, textarea:disabled {
     background-color: #dfdfdf;
     border: solid #dfdfdf 1px;
     color: #000000;
 }
 
-input:focus, select:focus, textarea:focus {
+input.text:focus, select:focus, textarea:focus {
     background-color: #ffffff;
     border: solid #29457f 2px;
-    padding: 3px;
     outline: none;
 }
 
-input.big:focus, select.big:focus, textarea.big:focus {
+input.text:focus, select:focus {
+    padding: 0 4px;
+}
+
+textarea:focus {
     padding: 4px;
 }
 
+input.text.big:focus, select.big:focus {
+    padding: 0 5px;
+}
+
+div.inputWithButton>input.text {
+    width: 100%;
+    padding: 0 83px 0 6px;
+}
+
+div.inputWithButton>input.text:focus {
+    padding: 0 82px 0 5px;
+}
+
+textarea.big:focus {
+    padding: 5px;
+}
+
 div.modal {
     position: fixed;
-    top: 100px;
     background-color: #ffffff;
     border-radius: 3px;
-    padding: 20px;
     box-sizing: border-box;
-    z-index: 3;
+    overflow-y: auto;
+    z-index: 6;
     visibility: hidden;
 }
 
@@ -263,7 +339,7 @@ div.modal {
     right: 0;
     background-color: #000000;
     opacity: 0.5;
-    z-index: 2;
+    z-index: 5;
     visibility: hidden;
 }
 
@@ -276,7 +352,7 @@ p.formError {
     display: none;
 }
 
-div.header {
+header {
     display: grid;
     grid-template-columns: auto auto;
     background-color: #333333;
@@ -286,33 +362,52 @@ div.header {
     color: white;
 }
 
-div.header.small {
+header.small {
     height: 40px;
     line-height: 40px;
 }
 
-div.header>p.header {
+header>p {
     line-height: inherit;
     text-align: right;
 }
 
-div.header>p.header>span {
+header>p>span {
     padding-left: 6px;
 }
 
-div.header>p.header>span>a:link, div.header>p.header>span>a:visited {
+header>p>span>a:link, header>p>span>a:visited, footer>p>a:link, footer>p>a:visited {
     color: inherit;
 }
 
-div.header>p.header>span:not(:last-child) {
+header>p>span:not(:last-child) {
     border-right: solid white 1px;
     padding-right: 6px;
 }
 
-div.main {
+main {
+    background-color: #ffffff;
     padding: 6px 12px;
 }
 
+main.full {
+    position: relative;
+    width: 100%;
+    height: calc(100% - 40px);
+    padding: 0;
+}
+
+footer {
+    background-color: #444444;
+    padding: 6px 12px;
+    color: white;
+    text-align: center;
+}
+
+footer>p {
+    font-size: 13px;
+}
+
 div.buttonContainer {
     height: 35px;
 }
@@ -321,6 +416,20 @@ div.buttonContainer>button {
     margin: 0 auto;
 }
 
+#cookiesNotice {
+    position: fixed;
+    left: 0;
+    bottom: 0;
+    right: 0;
+    margin: 20px;
+    background-color: #eeeeee;
+    border: solid #888888 1px;
+    border-radius: 3px;
+    padding: 10px;
+    text-align: center;
+    z-index: 10;
+}
+
 #loading {
     position: fixed;
     width: 64px;
@@ -329,7 +438,7 @@ div.buttonContainer>button {
     left: 50%;
     margin-top: -32px;
     margin-left: -32px;
-    z-index: 5;
+    z-index: 7;
     visibility: hidden;
 }
 
@@ -342,27 +451,128 @@ div.box {
     box-sizing: border-box;
 }
 
+.circleControl {
+    position: absolute;
+    width: 60px;
+    bottom: 20px;
+    right: 10px;
+}
+
+.circleControl .controlItem {
+    position: relative;
+    height: 60px;
+    margin-top: 10px;
+    opacity: 70%;
+    cursor: pointer;
+}
+
+.circleControl .controlItem:hover {
+    opacity: 100%;
+}
+
+.circleControl .controlItem div {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+}
+
+.circleControl .controlBackground {
+    width: 100%;
+    height: 100%;
+    opacity: 50%;
+}
+
+.circleControl .controlIcon {
+    width: 75%;
+    height: 75%;
+    margin: auto;
+    margin-top: 50%;
+    transform: translateY(-50%);
+}
+
 @media screen and (max-width: 599px) {
-    div.header h1 span {
+    header h1 span {
         display: none;
     }
+    footer>p:not(:first-child) {
+        margin-top: 4px;
+    }
     button, a.button {
         padding: 0;
         width: 100%;
     }
+    button.marginLeft, a.button.marginLeft {
+        margin-left: 0;
+    }
+    button.marginRight, a.button.marginRight {
+        margin-right: 0;
+    }
     div.modal {
         left: 20px;
         right: 20px;
+        padding-left: 15px;
+        padding-right: 15px;
     }
     div.box {
         width: initial;
     }
+    .circleControl {
+        width: 45px;
+    }
+    .circleControl .controlItem {
+        height: 45px;
+    }
 }
 
 @media screen and (min-width: 600px) {
+    footer>p {
+        display: inline;
+    }
+    footer>p:not(:first-child) {
+        padding-left: 6px;
+    }
+    footer>p:not(:last-child) {
+        border-right: solid white 1px;
+        padding-right: 6px;
+    }
     div.modal {
         width: 540px;
         left: 50%;
         margin-left: -270px;
+        padding-left: 20px;
+        padding-right: 20px;
+    }
+}
+
+@media screen and (max-height: 399px) {
+    div.modal {
+        top: 20px;
+        max-height: calc(100% - 40px);
+        padding-top: 10px;
+        padding-bottom: 10px;
+    }
+    .circleControl {
+        width: 45px;
+    }
+    .circleControl .controlItem {
+        height: 45px;
+    }
+}
+
+@media screen and (min-height: 400px) and (max-height: 499px) {
+    div.modal {
+        top: 50px;
+        max-height: calc(100% - 100px);
+        padding-top: 15px;
+        padding-bottom: 15px;
+    }
+}
+
+@media screen and (min-height: 500px) {
+    div.modal {
+        top: 75px;
+        max-height: calc(100% - 150px);
+        padding-top: 15px;
+        padding-bottom: 15px;
     }
 }

public/static/css/maps.css

@@ -13,12 +13,25 @@ div.mapItem.new {
     align-items: center;
 }
 
+div.mapItem.unlisted {
+    opacity: 0.6;
+}
+
 div.mapItem>div.title {
     background-color: #28a745;
     color: white;
     border-top-left-radius: 3px;
     border-top-right-radius: 3px;
-    padding: 4px 8px;
+    padding: 0 8px;
+    height: 35px;
+    line-height: 35px;
+}
+
+div.mapItem>div.title>p {
+    line-height: inherit;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
 }
 
 div.mapItem>div.title>p.title {
@@ -29,17 +42,16 @@ div.mapItem>div.title>p.title {
 div.mapItem>div.imgContainer {
     width: 100%;
     padding-top: 50%;
-    background: #cccccc;
-}
-
-div.mapItem>div.imgContainer>img {
-    width: 100%;
-    margin-top: -50%
+    background-color: #cccccc;
+    background-position: center;
+    background-repeat: no-repeat;
+    background-size: cover;
 }
 
 div.mapItem>div.inner {
     background-color: #eeeeee;
     padding: 10px 8px;
+    box-sizing: border-box;
 }
 
 div.mapItem>div.inner>div.info {
@@ -47,6 +59,12 @@ div.mapItem>div.inner>div.info {
     grid-template-columns: auto auto;
 }
 
+div.mapItem>div.inner>div.description {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+}
+
 div.mapItem>div.inner>div.info>p:nth-child(1) {
     text-align: left;
 }
@@ -61,6 +79,10 @@ div.mapItem>div.buttonContainer {
     grid-auto-flow: column;
 }
 
+#timeLimitType {
+    margin-left: 1.5em;
+}
+
 @media screen and (min-width: 1504px) {
     #mapContainer {
         grid-template-columns: auto auto auto auto;

public/static/img/circle_background.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%" viewBox="0 0 16 16">
+  <circle cx="50%" cy="50%" r="50%" fill="black" />
+</svg>

public/static/img/compass.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <polygon id="needleNorth" points="50,0 33,50 66,50" style="fill:red;stroke:black;stroke-width:1" />
+  <polygon id="needleSouth" points="50,100 33,50 66,50" style="fill:white;stroke:black;stroke-width:1" />
+  Sorry, your browser does not support inline SVG.
+</svg>

public/static/img/house-fill.svg

@@ -0,0 +1,5 @@
+<!-- Original image: Copyright (c) 2019 The Bootstrap Authors. License can be found in 'USED_SOFTWARE' in section 'Bootstrap Icons'. -->
+<svg xmlns="http://www.w3.org/2000/svg" width="100%" height="100%" fill="#3183ce" viewBox="0 0 16 16">
+  <path fill-rule="evenodd" d="m8 3.293 6 6V13.5a1.5 1.5 0 0 1-1.5 1.5h-9A1.5 1.5 0 0 1 2 13.5V9.293l6-6zm5-.793V6l-2-2V2.5a.5.5 0 0 1 .5-.5h1a.5.5 0 0 1 .5.5z"/>
+  <path fill-rule="evenodd" d="M7.293 1.5a1 1 0 0 1 1.414 0l6.647 6.646a.5.5 0 0 1-.708.708L8 2.207 1.354 8.854a.5.5 0 1 1-.708-.708L7.293 1.5z"/>
+</svg>

public/static/img/map.svg

@@ -0,0 +1,4 @@
+<!-- Copyright (c) 2019 The Bootstrap Authors. License can be found in 'USED_SOFTWARE' in section 'Bootstrap Icons'. -->
+<svg xmlns="http://www.w3.org/2000/svg" fill="#ffffff" viewBox="0 0 16 16">
+  <path fill-rule="evenodd" d="M15.817.113A.5.5 0 0 1 16 .5v14a.5.5 0 0 1-.402.49l-5 1a.502.502 0 0 1-.196 0L5.5 15.01l-4.902.98A.5.5 0 0 1 0 15.5v-14a.5.5 0 0 1 .402-.49l5-1a.5.5 0 0 1 .196 0L10.5.99l4.902-.98a.5.5 0 0 1 .415.103zM10 1.91l-4-.8v12.98l4 .8V1.91zm1 12.98 4-.8V1.11l-4 .8v12.98zm-6-.8V1.11l-4 .8v12.98l4-.8z"/>
+</svg>

public/static/img/markers/marker-blue-empty.svg

@@ -0,0 +1,10 @@
+<!-- Original image: Copyright (c) 2019 The Bootstrap Authors. License can be found in 'USED_SOFTWARE' in section 'Bootstrap Icons'. -->
+<svg viewBox="0 0 12 16" xmlns="http://www.w3.org/2000/svg">
+    <path
+        fill="#3183ce"
+        fill-rule="evenodd"
+        stroke="#19456d"
+        stroke-width="0.3"
+        stroke-linecap="round"
+        d="m 5.9999998,15.849652 c 0,0 5.8511182,-5.579947 5.8511182,-9.8134832 a 5.8511179,5.8880898 0 0 0 -11.7022358,0 c 0,4.2335362 5.8511176,9.8134832 5.8511176,9.8134832" />
+</svg>

public/static/img/street-view-cover.svg

@@ -0,0 +1,5 @@
+<!-- Copyright (c) 2019 The Bootstrap Authors. License can be found in 'USED_SOFTWARE' in section 'Bootstrap Icons'. -->
+<svg xmlns="http://www.w3.org/2000/svg" fill="#ffffff" viewBox="0 0 16 16">
+  <path d="m14.12 10.163 1.715.858c.22.11.22.424 0 .534L8.267 15.34a.598.598 0 0 1-.534 0L.165 11.555a.299.299 0 0 1 0-.534l1.716-.858 5.317 2.659c.505.252 1.1.252 1.604 0l5.317-2.66zM7.733.063a.598.598 0 0 1 .534 0l7.568 3.784a.3.3 0 0 1 0 .535L8.267 8.165a.598.598 0 0 1-.534 0L.165 4.382a.299.299 0 0 1 0-.535L7.733.063z"/>
+  <path d="m14.12 6.576 1.715.858c.22.11.22.424 0 .534l-7.568 3.784a.598.598 0 0 1-.534 0L.165 7.968a.299.299 0 0 1 0-.534l1.716-.858 5.317 2.659c.505.252 1.1.252 1.604 0l5.317-2.659z"/>
+</svg>

public/static/js/account/account.js

@@ -0,0 +1,69 @@
+var Account = {
+    original: null,
+    countdown: null,
+
+    openGoogleAuthenticate: function () {
+        window.open('/account/googleAuthenticate', 'googleAuthenticate', 'height=600,width=600')
+    },
+
+    authenticatedWithGoogleCallback: function (authenticatedWithGoogleUntil) {
+        var password = document.getElementsByTagName('form')[0].elements.password;
+        var button = document.getElementById('authenticateWithGoogleButton');
+
+        Account.original = {
+            type: password.type,
+            placeholder: password.placeholder,
+            required: password.required,
+            disabled: password.disabled
+        };
+
+        password.type = 'text';
+        password.placeholder = 'Authenticated!'
+        password.value = '';
+        password.required = false;
+        password.disabled = true;
+
+        button.disabled = true;
+
+        Account.countdown = setInterval(function () {
+            var timeLeft = Math.ceil((authenticatedWithGoogleUntil.getTime() - new Date().getTime()) / 1000);
+
+            if (timeLeft > 30) {
+                return;
+            }
+
+            if (timeLeft <= 0) {
+                Account.resetGoogleAuthentication();
+                return;
+            }
+
+            password.placeholder = 'Authenticated! ' + timeLeft + ' seconds left...';
+        }, 1000);
+    },
+
+    resetGoogleAuthentication: function () {
+        if (Account.countdown !== null) {
+            clearInterval(Account.countdown);
+        }
+
+        var password = document.getElementsByTagName('form')[0].elements.password;
+        var button = document.getElementById('authenticateWithGoogleButton');
+
+        password.type = Account.original.type;
+        password.placeholder = Account.original.placeholder
+        password.required = Account.original.required;
+        password.disabled = Account.original.disabled;
+
+        button.disabled = false;
+    }
+};
+
+(function () {
+    document.getElementById('authenticateWithGoogleButton').onclick = function () {
+        Account.openGoogleAuthenticate();
+    };
+
+    document.getElementsByTagName('form')[0].onreset = function () {
+        Account.resetGoogleAuthentication();
+    };
+})();

public/static/js/account/google_authenticate.js

@@ -0,0 +1,10 @@
+(function () {
+    if (success) {
+        window.opener.Account.authenticatedWithGoogleCallback(authenticatedWithGoogleUntil);
+        window.close();
+    } else {
+        document.getElementById('closeWindowButton').onclick = function () {
+            window.close();
+        }
+    }
+})();

public/static/js/login.js

@@ -1,40 +0,0 @@
-(function () {
-    var form = document.getElementById('loginForm');
-
-    form.onsubmit = function (e) {
-        document.getElementById('loading').style.visibility = 'visible';
-
-        e.preventDefault();
-
-        var formData = new FormData(form);
-
-        MapGuesser.httpRequest('POST', form.action, function () {
-            if (this.response.error) {
-                var errorText;
-                switch (this.response.error) {
-                    case 'user_not_found':
-                        errorText = 'No user found with the given email address. You can <a href="/signup" title="Sign up">sign up here</a>!';
-                        break;
-                    case 'user_not_active':
-                        errorText = 'User found with the given email address, but the account is not activated. Please check your email and click on the activation link!';
-                        break;
-                    case 'password_not_match':
-                        errorText = 'The given password is wrong.'
-                        break;
-                }
-
-                document.getElementById('loading').style.visibility = 'hidden';
-
-                var loginFormError = document.getElementById('loginFormError');
-                loginFormError.style.display = 'block';
-                loginFormError.innerHTML = errorText;
-
-                form.elements.email.select();
-
-                return;
-            }
-
-            window.location.replace('/');
-        }, formData);
-    };
-})();

public/static/js/login/google_signup.js

@@ -0,0 +1,9 @@
+(function () {
+    document.getElementById('cancelGoogleSignupButton').onclick = function () {
+        document.getElementById('loading').style.visibility = 'visible';
+
+        MapGuesser.httpRequest('POST', '/signup/google/reset', function () {
+            window.location.replace('/signup');
+        });
+    };
+})();

public/static/js/login/signup.js

@@ -0,0 +1,12 @@
+(function () {
+    var resetSignupButton = document.getElementById('resetSignupButton');
+    if (resetSignupButton) {
+        resetSignupButton.onclick = function () {
+            document.getElementById('loading').style.visibility = 'visible';
+
+            MapGuesser.httpRequest('POST', '/signup/reset', function () {
+                window.location.reload();
+            });
+        };
+    }
+})();

public/static/js/map_editor.js

@@ -7,7 +7,6 @@
             description: null
         },
         map: null,
-        markers: null,
         panorama: null,
         selectedMarker: null,
         added: {},
@@ -19,6 +18,7 @@
 
             MapEditor.metadata.name = form.elements.name.value;
             MapEditor.metadata.description = form.elements.description.value;
+            MapEditor.metadata.unlisted = form.elements.unlisted.checked;
 
             document.getElementById('mapName').innerHTML = form.elements.name.value ? form.elements.name.value : '[unnamed map]';
 
@@ -87,7 +87,7 @@
             sv.getPanorama({
                 location: location,
                 preference: google.maps.StreetViewPreference.NEAREST,
-                radius: 100,
+                radius: MapEditor.map.getSearchRadius(location),
                 source: canBeIndoor ? google.maps.StreetViewSource.DEFAULT : google.maps.StreetViewSource.OUTDOOR
             }, function (data, status) {
                 var panoLocationData = status === google.maps.StreetViewStatus.OK ? data.location : null;
@@ -118,16 +118,13 @@
             MapEditor.resetSelected();
             MapEditor.selectedMarker = marker;
 
-            MapEditor.map.invalidateSize(true);
+            MapEditor.map.resize();
             MapEditor.map.panTo(marker.getLatLng());
 
             MapEditor.panorama.setVisible(false);
 
             if (marker.placeId) {
-                MapEditor.markers.removeLayer(MapEditor.selectedMarker);
-                MapEditor.map.addLayer(MapEditor.selectedMarker);
-                marker.setIcon(IconCollection.iconBlue);
-                marker.setZIndexOffset(2000);
+                MapEditor.map.changeMarkerIcon(marker, MapEditor.map.iconCollection.iconBlue);
 
                 document.getElementById('deleteButton').style.display = 'block';
 
@@ -165,13 +162,13 @@
             var placeId = MapEditor.selectedMarker.placeId
 
             if (places[placeId].id && !del) {
-                MapEditor.map.removeLayer(MapEditor.selectedMarker);
-                MapEditor.markers.addLayer(MapEditor.selectedMarker);
-                MapEditor.selectedMarker.setIcon(places[placeId].noPano ? IconCollection.iconRed : IconCollection.iconGreen);
-                MapEditor.selectedMarker.setZIndexOffset(1000);
+                MapEditor.map.changeMarkerIcon(
+                    MapEditor.selectedMarker,
+                    places[placeId].noPano ? MapEditor.map.iconCollection.iconRed : MapEditor.map.iconCollection.iconGreen
+                );
             } else {
                 delete places[placeId];
-                MapEditor.map.removeLayer(MapEditor.selectedMarker);
+                MapEditor.map.removeMarker(MapEditor.selectedMarker);
             }
 
             document.getElementById('deleteButton').style.display = 'none';
@@ -223,7 +220,7 @@
             MapEditor.resetSelected(del);
             MapEditor.selectedMarker = null;
 
-            MapEditor.map.invalidateSize(true);
+            MapEditor.map.resize();
         },
 
         deletePlace: function () {
@@ -239,6 +236,7 @@
 
             delete MapEditor.added[placeId];
             delete MapEditor.edited[placeId];
+            delete places[placeId];
 
             document.getElementById('added').innerHTML = String(Object.keys(MapEditor.added).length);
             document.getElementById('edited').innerHTML = String(Object.keys(MapEditor.edited).length);
@@ -257,6 +255,9 @@
             if (MapEditor.metadata.description !== null) {
                 data.append('description', MapEditor.metadata.description);
             }
+            if (MapEditor.metadata.unlisted !== null) {
+                data.append('unlisted', MapEditor.metadata.unlisted);
+            }
 
             for (var placeId in MapEditor.added) {
                 if (!MapEditor.added.hasOwnProperty(placeId)) {
@@ -313,91 +314,346 @@
         }
     };
 
-    var IconCollection = {
-        iconGreen: L.icon({
-            iconUrl: STATIC_ROOT + '/img/markers/marker-green.svg?rev' + REVISION,
-            iconSize: [24, 32],
-            iconAnchor: [12, 32]
-        }),
-        iconRed: L.icon({
-            iconUrl: STATIC_ROOT + '/img/markers/marker-red.svg?rev=' + REVISION,
-            iconSize: [24, 32],
-            iconAnchor: [12, 32]
-        }),
-        iconBlue: L.icon({
-            iconUrl: STATIC_ROOT + '/img/markers/marker-blue.svg?rev=' + REVISION,
-            iconSize: [24, 32],
-            iconAnchor: [12, 32]
-        }),
-    };
-
     var Util = {
         getHighResData: function () {
             if (window.devicePixelRatio >= 4) {
-                return { ppi: 320, tileSize: 128, zoomOffset: 1 };
+                return { ppi: 320, tileSize: 128, zoomOffset: 1, minZoom: 0, maxZoom: 18 };
             } else if (window.devicePixelRatio >= 2) {
-                return { ppi: 250, tileSize: 256, zoomOffset: 0 };
+                return { ppi: 250, tileSize: 256, zoomOffset: 0, minZoom: 1, maxZoom: 19 };
             } else {
-                return { ppi: 72, tileSize: 512, zoomOffset: -1 };
+                return { ppi: 72, tileSize: 512, zoomOffset: -1, minZoom: 2, maxZoom: 20 };
             }
+        },
+
+        extractCoordinates: function (coordinatesStr) {
+            var coordinates = { valid: false, latlng: { lat: 0., lng: 0. } };
+            var delimiters = [',', ' ', ';'];
+
+            coordinatesStr = coordinatesStr.trim();
+            if (coordinatesStr.length == 0) {
+                return coordinates;
+            }
+
+            for (var delimiter of delimiters) {
+                if (coordinatesStr.indexOf(delimiter) != -1) {
+
+                    var coordinatesArr = coordinatesStr.split(delimiter);
+                    coordinates.latlng.lat = parseFloat(coordinatesArr[0]);
+                    coordinates.latlng.lng = parseFloat(coordinatesArr[1]);
+
+                    if (!isNaN(coordinates.latlng.lat) && !isNaN(coordinates.latlng.lng)) {
+                        coordinates.valid = true;
+                        return coordinates;
+                    }
+                }
+            }
+
+            return coordinates;
         }
     };
 
-    MapEditor.map = L.map('map', {
-        zoomControl: false
-    });
+    var LMapWrapper = {
+        map: null,
+        markers: null,
+        divId: null,
+        iconCollection: {
+            iconGreen: L.icon({
+                iconUrl: STATIC_ROOT + '/img/markers/marker-green.svg?rev' + REVISION,
+                iconSize: [24, 32],
+                iconAnchor: [12, 32]
+            }),
+            iconRed: L.icon({
+                iconUrl: STATIC_ROOT + '/img/markers/marker-red.svg?rev=' + REVISION,
+                iconSize: [24, 32],
+                iconAnchor: [12, 32]
+            }),
+            iconBlue: L.icon({
+                iconUrl: STATIC_ROOT + '/img/markers/marker-blue.svg?rev=' + REVISION,
+                iconSize: [24, 32],
+                iconAnchor: [12, 32]
+            })
+        },
 
-    MapEditor.map.on('click', function (e) {
-        var marker = L.marker(e.latlng, {
-            icon: IconCollection.iconBlue,
-            zIndexOffset: 2000
-        })
-            .addTo(MapEditor.map)
-            .on('click', function () {
-                MapEditor.select(this);
-            });
+        init: function (divId, places) {
+            document.getElementById(divId).style.display = "block";
 
-        MapEditor.select(marker);
-    });
+            if (!LMapWrapper.map) {
+                LMapWrapper.divId = divId;
+                LMapWrapper.map = L.map(LMapWrapper.divId, {
+                    center: { lat: 0., lng: 0. },
+                    zoom: 2
+                });
 
-    var highResData = Util.getHighResData();
+                LMapWrapper.map.on('click', function (e) {
+                    LMapWrapper.placeMarker(e.latlng);
+                });
 
-    L.tileLayer(tileUrl, {
-        attribution: tileAttribution,
-        subdomains: '1234',
-        ppi: highResData.ppi,
-        tileSize: highResData.tileSize,
-        zoomOffset: highResData.zoomOffset,
-        minZoom: 2,
-        maxZoom: 20
-    }).addTo(MapEditor.map);
+                var highResData = Util.getHighResData();
 
-    MapEditor.map.fitBounds(L.latLngBounds({ lat: mapBounds.south, lng: mapBounds.west }, { lat: mapBounds.north, lng: mapBounds.east }));
+                L.tileLayer(tileUrl, {
+                    attribution: tileAttribution,
+                    subdomains: tileSubdomains,
+                    ppi: highResData.ppi,
+                    tileSize: highResData.tileSize,
+                    zoomOffset: highResData.zoomOffset,
+                    minZoom: highResData.minZoom,
+                    maxZoom: highResData.maxZoom
+                }).addTo(LMapWrapper.map);
 
-    MapEditor.markers = L.markerClusterGroup({
-        maxClusterRadius: 50
-    });
+                if (mapId) {
+                    LMapWrapper.map.fitBounds(L.latLngBounds({ lat: mapBounds.south, lng: mapBounds.west }, { lat: mapBounds.north, lng: mapBounds.east }));
+                }
+            }
 
-    for (var placeId in places) {
-        if (!places.hasOwnProperty(placeId)) {
-            continue;
+            LMapWrapper.loadMarkers(places);
+
+            document.getElementById('streetViewCoverSelector').style.display = 'none';
+        },
+
+        hide: function () {
+            document.getElementById(LMapWrapper.divId).style.display = 'none';
+        },
+
+        loadMarkers: function (places) {
+            if (!LMapWrapper.markers) {
+                LMapWrapper.markers = L.markerClusterGroup({
+                    maxClusterRadius: 50
+                });
+            } else {
+                LMapWrapper.markers.clearLayers();
+            }
+
+            for (var placeId in places) {
+                if (!places.hasOwnProperty(placeId)) {
+                    continue;
+                }
+
+                var place = places[placeId];
+
+                var marker = L.marker({ lat: place.lat, lng: place.lng }, {
+                    icon: place.noPano ? LMapWrapper.iconCollection.iconRed : LMapWrapper.iconCollection.iconGreen,
+                    zIndexOffset: 1000
+                })
+                    .addTo(LMapWrapper.markers)
+                    .on('click', function () {
+                        MapEditor.select(this);
+                    });
+
+                marker.placeId = placeId;
+            }
+
+            LMapWrapper.map.addLayer(LMapWrapper.markers);
+        },
+
+        // TODO: check whether marker is already existing on the map for the coordinates
+        //       or alternatively block saving for matching coordinates
+        placeMarker: function (latLng) {
+            var marker = L.marker(latLng, {
+                icon: LMapWrapper.iconCollection.iconBlue,
+                zIndexOffset: 2000
+            })
+                .addTo(LMapWrapper.markers)
+                .on('click', function () {
+                    MapEditor.select(this);
+                });
+
+            MapEditor.select(marker);
+        },
+
+        panTo: function (latLng) {
+            LMapWrapper.map.panTo(latLng);
+        },
+
+        resize: function () {
+            LMapWrapper.map.invalidateSize(true);
+        },
+
+        changeMarkerIcon: function (marker, icon) {
+            marker.setIcon(icon);
+            marker.setZIndexOffset(2000);
+        },
+
+        removeMarker: function (marker) {
+            LMapWrapper.markers.removeLayer(marker);
+        },
+
+        toggleStreetViewCover: function () { },
+
+        getSearchRadius: function (location) {
+            return 100;
         }
+    };
 
-        var place = places[placeId];
+    var GMapWrapper = {
+        map: null,
+        markers: null,
+        divId: null,
+        streetViewCover: null,
+        streetViewCoverOn: false,
+        iconCollection: {
+            iconGreen: {
+                url: STATIC_ROOT + '/img/markers/marker-green.svg?rev' + REVISION,
+                scaledSize: new google.maps.Size(24, 32), // scaled size
+                origin: new google.maps.Point(0, 0), // origin
+                anchor: new google.maps.Point(12, 32) // anchor
+            },
+            iconRed: {
+                url: STATIC_ROOT + '/img/markers/marker-red.svg?rev' + REVISION,
+                scaledSize: new google.maps.Size(24, 32), // scaled size
+                origin: new google.maps.Point(0, 0), // origin
+                anchor: new google.maps.Point(12, 32) // anchor
+            },
+            iconBlue: {
+                url: STATIC_ROOT + '/img/markers/marker-blue.svg?rev' + REVISION,
+                scaledSize: new google.maps.Size(24, 32), // scaled size
+                origin: new google.maps.Point(0, 0), // origin
+                anchor: new google.maps.Point(12, 32) // anchor
+            }
+        },
 
-        var marker = L.marker({ lat: place.lat, lng: place.lng }, {
-            icon: place.noPano ? IconCollection.iconRed : IconCollection.iconGreen,
-            zIndexOffset: 1000
-        })
-            .addTo(MapEditor.markers)
-            .on('click', function () {
+        init: function (divId, places) {
+            document.getElementById(divId).style.display = "block";
+
+            if (!GMapWrapper.map) {
+                GMapWrapper.divId = divId;
+                GMapWrapper.map = new google.maps.Map(document.getElementById(GMapWrapper.divId), {
+                    center: { lat: 0., lng: 0. },
+                    zoom: 2,
+                    fullscreenControl: false,
+                    zoomControl: true,
+                    zoomControlOptions: {
+                        position: google.maps.ControlPosition.LEFT_BOTTOM
+                    },
+                    streetViewControl: false,
+                    draggableCursor: 'crosshair'
+                });
+
+                GMapWrapper.streetViewCover = new google.maps.StreetViewCoverageLayer();
+
+                GMapWrapper.map.addListener('click', function (mapsMouseEvent) {
+                    GMapWrapper.placeMarker({
+                        lat: mapsMouseEvent.latLng.lat(),
+                        lng: mapsMouseEvent.latLng.lng()
+                    });
+                });
+
+                if (mapId) {
+                    GMapWrapper.map.fitBounds({ south: mapBounds.south, west: mapBounds.west, north: mapBounds.north, east: mapBounds.east });
+                }
+            }
+
+            GMapWrapper.loadMarkers(places);
+
+            document.getElementById('streetViewCoverSelector').style.display = 'block'
+        },
+
+        hide: function () {
+            document.getElementById(GMapWrapper.divId).style.display = 'none';
+        },
+
+        loadMarkers: function (places) {
+            if (!GMapWrapper.markers) {
+                GMapWrapper.markers = new MarkerClusterer(GMapWrapper.map, [], {
+                    imagePath: STATIC_ROOT + '/img/markers/m',
+                    imageExtension: 'png?rev' + REVISION
+                });
+            } else {
+                GMapWrapper.markers.clearMarkers();
+            }
+
+            for (var placeId in places) {
+                if (!places.hasOwnProperty(placeId)) {
+                    continue;
+                }
+
+                var place = places[placeId];
+
+                var marker = new google.maps.Marker({
+                    position: {
+                        lat: place.lat,
+                        lng: place.lng
+                    },
+                    icon: place.noPano ? GMapWrapper.iconCollection.iconRed : GMapWrapper.iconCollection.iconGreen
+                });
+
+                marker.getLatLng = function () { return { lat: this.getPosition().lat(), lng: this.getPosition().lng() } };
+                marker.setLatLng = function (coords) { this.setPosition(coords) };
+
+                marker.addListener('click', function () {
+                    MapEditor.select(this);
+                });
+
+                marker.placeId = placeId;
+
+                GMapWrapper.markers.addMarker(marker);
+            }
+        },
+
+        // TODO: check whether marker is already existing on the map for the coordinates
+        //       or alternatively block saving for matching coordinates
+        placeMarker: function (latLng) {
+            var marker = new google.maps.Marker({
+                map: GMapWrapper.map,
+                position: latLng,
+                icon: GMapWrapper.iconCollection.iconBlue,
+            });
+
+            marker.getLatLng = function () { return { lat: this.getPosition().lat(), lng: this.getPosition().lng() } };
+            marker.setLatLng = function (coords) { this.setPosition(coords) };
+
+            marker.addListener('click', function () {
                 MapEditor.select(this);
             });
 
-        marker.placeId = place.id;
-    }
+            GMapWrapper.markers.addMarker(marker);
 
-    MapEditor.map.addLayer(MapEditor.markers);
+            MapEditor.select(marker);
+        },
+
+        panTo: function (latLng) {
+            GMapWrapper.map.panTo(latLng);
+        },
+
+        resize: function () {
+            google.maps.event.trigger(GMapWrapper.map, 'resize');
+        },
+
+        changeMarkerIcon: function (marker, icon) {
+            marker.setIcon(icon);
+        },
+
+        removeMarker: function (marker) {
+            GMapWrapper.markers.removeMarker(marker);
+        },
+
+        toggleStreetViewCover: function () {
+            if (GMapWrapper.streetViewCoverOn) {
+                GMapWrapper.streetViewCover.setMap(null);
+                GMapWrapper.streetViewCoverOn = false;
+            } else {
+                GMapWrapper.streetViewCover.setMap(GMapWrapper.map);
+                GMapWrapper.streetViewCoverOn = true;
+            }
+        },
+
+        getSearchRadius: function (location) {
+            // source: https://www.yorku.ca/mack/CHI01.htm
+            var movementOffset = 4;
+
+            // source: https://groups.google.com/g/google-maps-js-api-v3/c/hDRO4oHVSeM/m/osOYQYXg2oUJ?pli=1
+            var metersPerPixel = 156543.03392 * Math.cos(location.lat * Math.PI / 180) / Math.pow(2, GMapWrapper.map.getZoom());
+
+            var minSearchRadius = 5;
+
+            var searchRadius = Math.max(minSearchRadius, Math.round(movementOffset * metersPerPixel));
+
+            return searchRadius;
+        }
+    };
+
+    // initialize content of #map with google maps
+    MapEditor.map = GMapWrapper;
+    MapEditor.map.init('gmap', places);
 
     MapEditor.panorama = new google.maps.StreetViewPanorama(document.getElementById('panorama'), {
         // switch off fullscreenControl because positioning doesn't work
@@ -440,4 +696,48 @@
     document.getElementById('deleteButton').onclick = function () {
         MapEditor.deletePlace();
     };
+
+    document.getElementById('jumpButton').onclick = function (e) {
+        var coordinatesStr = document.getElementById("jumpCoordinates").value;
+        var coordinates = Util.extractCoordinates(coordinatesStr);
+
+        if (coordinates.valid) {
+            MapEditor.map.placeMarker(coordinates.latlng);
+        }
+    };
+
+    document.getElementById('jumpCoordinates').onkeyup = function (e) {
+        var coordinatesStr = document.getElementById("jumpCoordinates").value;
+        var coordinates = Util.extractCoordinates(coordinatesStr);
+        var jumpButton = document.getElementById("jumpButton");
+
+        if (coordinates.valid) {
+            jumpButton.disabled = false;
+
+            if (e.key == 'Enter') {
+                MapEditor.map.placeMarker(coordinates.latlng);
+            }
+        }
+        else {
+            jumpButton.disabled = true;
+        }
+    };
+
+    document.getElementById('mapSelector').onclick = function () {
+        MapEditor.closePlace();
+        MapEditor.map.hide();
+
+        if (MapEditor.map === GMapWrapper) {
+            MapEditor.map = LMapWrapper;
+            MapEditor.map.init('lmap', places);
+        } else {
+            MapEditor.map = GMapWrapper;
+            MapEditor.map.init('gmap', places);
+        }
+    }
+
+    document.getElementById('streetViewCoverSelector').onclick = function () {
+        MapEditor.map.toggleStreetViewCover();
+    }
+
 })();

public/static/js/mapguesser.js

@@ -1,12 +1,59 @@
 var MapGuesser = {
+    isSecure: window.location.protocol === 'https:',
+    cookiesAgreed: false,
+    sessionAvailableHooks: {},
+
+    initGoogleAnalitics: function () {
+        if (typeof GOOGLE_ANALITICS_ID === 'undefined') {
+            return;
+        }
+
+        // Global site tag (gtag.js) - Google Analytics
+        var script = document.createElement('script');
+        script.src = 'https://www.googletagmanager.com/gtag/js?id=' + GOOGLE_ANALITICS_ID;
+        script.async = true;
+
+        document.head.appendChild(script);
+
+        window.dataLayer = window.dataLayer || [];
+        function gtag() { dataLayer.push(arguments); }
+        gtag('js', new Date());
+        gtag('config', GOOGLE_ANALITICS_ID);
+    },
+
+    agreeCookies: function () {
+        if (MapGuesser.cookiesAgreed) {
+            return;
+        }
+
+        var expirationDate = new Date(new Date().getTime() + 20 * 365 * 24 * 60 * 60 * 1000).toUTCString();
+        document.cookie = 'COOKIES_CONSENT=1; expires=' + expirationDate + '; path=/';
+
+        MapGuesser.initGoogleAnalitics();
+        MapGuesser.httpRequest('GET', '/startSession.json', function () {
+            ANTI_CSRF_TOKEN = this.response.antiCsrfToken;
+
+            for (var hookId in MapGuesser.sessionAvailableHooks) {
+                if (!MapGuesser.sessionAvailableHooks.hasOwnProperty(hookId)) {
+                    continue;
+                }
+
+                MapGuesser.sessionAvailableHooks[hookId]();
+            }
+        });
+
+        MapGuesser.cookiesAgreed = true;
+    },
+
     httpRequest: function (method, url, callback, data) {
         var xhr = new XMLHttpRequest();
 
-        xhr.responseType = 'json';
         xhr.onload = callback;
 
         xhr.open(method, url, true);
 
+        xhr.responseType = 'json';
+
         if (method === 'POST') {
             if (typeof data === 'undefined') {
                 data = new FormData();
@@ -20,6 +67,55 @@ var MapGuesser = {
         }
     },
 
+    setOnsubmitForForm: function (form) {
+        form.onsubmit = function (e) {
+            e.preventDefault();
+
+            document.getElementById('loading').style.visibility = 'visible';
+
+            var formData = new FormData(form);
+            var formError = form.getElementsByClassName('formError')[0];
+            var pageLeaveOnSuccess = form.dataset.redirectOnSuccess || form.dataset.reloadOnSuccess;
+
+            MapGuesser.httpRequest('POST', form.action, function () {
+                if (!pageLeaveOnSuccess) {
+                    document.getElementById('loading').style.visibility = 'hidden';
+                }
+
+                if (this.response.error) {
+                    if (pageLeaveOnSuccess) {
+                        document.getElementById('loading').style.visibility = 'hidden';
+                    }
+
+                    formError.style.display = 'block';
+                    formError.innerHTML = this.response.error.errorText;
+                    if (typeof grecaptcha !== 'undefined') {
+                        grecaptcha.reset();
+                    }
+
+                    return;
+                }
+
+                if (this.response.redirect) {
+                    window.location.replace(this.response.redirect.target);
+
+                    return;
+                }
+
+                if (!pageLeaveOnSuccess) {
+                    formError.style.display = 'none';
+                    form.reset();
+                } else {
+                    if (form.dataset.redirectOnSuccess) {
+                        window.location.replace(form.dataset.redirectOnSuccess);
+                    } else if (form.dataset.reloadOnSuccess) {
+                        window.location.reload();
+                    }
+                }
+            }, formData);
+        }
+    },
+
     showModal: function (id) {
         document.getElementById(id).style.visibility = 'visible';
         document.getElementById('cover').style.visibility = 'visible';
@@ -90,11 +186,46 @@ var MapGuesser = {
         document.getElementById('cover').style.visibility = 'hidden';
     },
 
-    toggleDisableOnChange: function (input, button) {
-        if (input.defaultValue !== input.value) {
-            button.disabled = false;
-        } else {
-            button.disabled = true;
+    observeInput: function (form, observedInputs) {
+        var anyChanged = false;
+
+        for (var i = 0; i < observedInputs.length; i++) {
+            var input = form.elements[observedInputs[i]];
+            if (input.type === 'checkbox') {
+                if (input.defaultChecked !== input.checked) {
+                    anyChanged = true;
+                }
+            } else {
+                if (input.defaultValue !== input.value) {
+                    anyChanged = true;
+                }
+            }
+        }
+
+        form.elements['submit_button'].disabled = !anyChanged;
+    },
+
+    observeInputsInForm: function (form, observedInputs) {
+        for (var i = 0; i < observedInputs.length; i++) {
+            var input = form.elements[observedInputs[i]];
+
+            switch (input.tagName) {
+                case 'INPUT':
+                case 'TEXTAREA':
+                    input.oninput = function () {
+                        MapGuesser.observeInput(form, observedInputs);
+                    };
+                    break;
+                case 'SELECT':
+                    input.onchange = function () {
+                        MapGuesser.observeInput(form, observedInputs);
+                    };
+                    break;
+            }
+        }
+
+        form.onreset = function () {
+            form.elements['submit_button'].disabled = true;
         }
     }
 };
@@ -110,7 +241,41 @@ var MapGuesser = {
         }
     }
 
+    var forms = document.getElementsByTagName('form');
+    for (var i = 0; i < forms.length; i++) {
+        var form = forms[i];
+
+        if (form.dataset.noSubmit) {
+            continue;
+        }
+
+        MapGuesser.setOnsubmitForForm(form);
+
+        if (form.dataset.observeInputs) {
+            MapGuesser.observeInputsInForm(form, form.dataset.observeInputs.split(','));
+        }
+    }
+
     document.getElementById('cover').onclick = function () {
         MapGuesser.hideModal();
     };
+
+    if (COOKIES_CONSENT) {
+        MapGuesser.initGoogleAnalitics();
+    } else {
+        // we don't want user to agree cookies when clicking on the notice itself
+        document.getElementById('cookiesNotice').onclick = function (e) {
+            e.stopPropagation();
+        };
+
+        document.getElementById('agreeCookiesButton').onclick = function () {
+            MapGuesser.agreeCookies();
+
+            document.getElementById('cookiesNotice').style.display = 'none';
+        };
+
+        window.onclick = function () {
+            MapGuesser.agreeCookies();
+        };
+    }
 })();

public/static/js/maps.js

@@ -0,0 +1,181 @@
+(function () {
+    var Maps = {
+        descriptionDivs: null,
+
+        addStaticMaps: function () {
+            var imgContainers = document.getElementById('mapContainer').getElementsByClassName('imgContainer');
+            for (var i = 0; i < imgContainers.length; i++) {
+                var imgContainer = imgContainers[i];
+
+                var imgSrc = 'https://maps.googleapis.com/maps/api/staticmap?size=350x175&' +
+                    'scale=' + (window.devicePixelRatio >= 2 ? 2 : 1) + '&' +
+                    'visible=' + imgContainer.dataset.boundSouthLat + ',' + imgContainer.dataset.boundWestLng + '|' +
+                    imgContainer.dataset.boundNorthLat + ',' + imgContainer.dataset.boundEastLng +
+                    '&key=' + GOOGLE_MAPS_JS_API_KEY;
+
+                imgContainer.style.backgroundImage = 'url("' + imgSrc + '")';
+            }
+        },
+
+        initializeDescriptionDivs: function () {
+            Maps.descriptionDivs = document.getElementById('mapContainer').getElementsByClassName('description');
+
+            for (var i = 0; i < Maps.descriptionDivs.length; i++) {
+                var description = Maps.descriptionDivs[i];
+                var boundingClientRect = description.getBoundingClientRect();
+
+                description.defaultHeight = boundingClientRect.height;
+            }
+        },
+
+        calculateDescriptionDivHeights: function () {
+            var currentY;
+            var rows = [];
+            for (var i = 0; i < Maps.descriptionDivs.length; i++) {
+                var description = Maps.descriptionDivs[i];
+                var boundingClientRect = description.getBoundingClientRect();
+
+                if (currentY !== boundingClientRect.y) {
+                    rows.push([]);
+                }
+
+                rows[rows.length - 1].push(description);
+
+                currentY = boundingClientRect.y;
+            }
+
+            for (var i = 0; i < rows.length; i++) {
+                var row = rows[i];
+
+                var maxHeight = 0;
+                for (var j = 0; j < row.length; j++) {
+                    var description = row[j];
+
+                    if (description.defaultHeight > maxHeight) {
+                        maxHeight = description.defaultHeight;
+                    }
+                }
+
+                for (var j = 0; j < row.length; j++) {
+                    var description = row[j];
+
+                    description.style.height = maxHeight + 'px';
+                }
+            }
+        }
+    };
+
+    var Util = {
+        printTimeForHuman: function (time) {
+            const minutes = Math.floor(time / 60);
+            const seconds = time % 60;
+            var time_str = '';
+
+            if (minutes == 1) {
+                time_str += '1 minute';
+            } else if (minutes > 1) {
+                time_str += minutes + ' minutes';
+            }
+
+            if (minutes > 0 && seconds > 0) {
+                time_str += ' and ';
+            }
+
+            if (seconds == 1) {
+                time_str += '1 second';
+            } else if (seconds > 1) {
+                time_str += seconds + ' seconds';
+            }
+
+            return time_str;
+        }
+    };
+
+    Maps.addStaticMaps();
+
+    Maps.initializeDescriptionDivs();
+    Maps.calculateDescriptionDivHeights();
+
+    window.onresize = function () {
+        Maps.calculateDescriptionDivHeights();
+    };
+
+    document.getElementById('multiForm').onsubmit = function (e) {
+        e.preventDefault();
+
+        var roomId = this.elements.roomId.value;
+        if (roomId.length !== 6) {
+            return;
+        }
+
+        window.location.href = '/multiGame/' + this.elements.roomId.value;
+    };
+
+    document.getElementById('challengeForm').onsubmit = function (e) {
+        e.preventDefault();
+
+        var url = '/challenge/create.json';
+        var formData = new FormData(this);
+
+        document.getElementById('loading').style.visibility = 'visible';
+        MapGuesser.httpRequest('POST', url, function() {
+            document.getElementById('loading').style.visibility = 'hidden';
+
+            if (this.response.error) {
+                Game.handleErrorResponse(this.response.error);
+                return;
+            }
+
+            window.location.href = '/challenge/' + this.response.challengeToken;
+
+        }, formData);
+    };
+
+    if (document.getElementById('multiButton')) {
+        document.getElementById('multiButton').onclick = function () {
+            MapGuesser.showModal('multi');
+            document.getElementById('createNewRoomButton').href = '/multiGame/new/' + this.dataset.mapId;
+            document.getElementById('multiForm').elements.roomId.select();
+            document.getElementById('playMode').style.visibility = 'hidden';
+        }
+    }
+
+    if (document.getElementById('challengeButton')) {
+        document.getElementById('challengeButton').onclick = function () {
+            MapGuesser.showModal('challenge');
+            document.getElementById('playMode').style.visibility = 'hidden';
+            var timeLimit = document.getElementById('timeLimit').value;
+            document.getElementById('timeLimitLabel').innerText = 'Time limit of ' + Util.printTimeForHuman(timeLimit);
+        };
+    }
+
+    document.getElementById('closePlayModeButton').onclick = function () {
+        MapGuesser.hideModal();
+    };
+
+    document.getElementById('closeMultiButton').onclick = function () {
+        MapGuesser.hideModal();
+    };
+
+    document.getElementById('closeChallengeButton').onclick = function () {
+        MapGuesser.hideModal();
+    }
+
+    var buttons = document.getElementById('mapContainer').getElementsByClassName('playButton');
+    for (var i = 0; i < buttons.length; i++) {
+        var button = buttons[i];
+
+        button.onclick = function () {
+            MapGuesser.showModal('playMode');
+            document.getElementById('singleButton').href = '/game/' + this.dataset.mapId;
+            document.getElementById('multiButton').dataset.mapId = this.dataset.mapId;
+            document.getElementById('challengeMapId').value = this.dataset.mapId;
+        };
+    }
+
+    document.getElementById('timeLimit').oninput = function () {
+        var timeLimit = document.getElementById('timeLimit').value;
+        document.getElementById('timeLimitLabel').innerText = 'Time limit of ' + Util.printTimeForHuman(timeLimit);
+        document.getElementById('timerEnabled').checked = true;
+    }
+})();

public/static/js/maps_admin.js

@@ -0,0 +1,34 @@
+(function () {
+    Maps = {
+        deleteMap: function (mapId, mapName) {
+            MapGuesser.showModalWithContent('Delete map', 'Are you sure you want to delete map \'' + mapName + '\'?', [{
+                type: 'button',
+                classNames: ['red'],
+                text: 'Delete',
+                onclick: function () {
+                    document.getElementById('loading').style.visibility = 'visible';
+
+                    MapGuesser.httpRequest('POST', '/admin/deleteMap/' + mapId, function () {
+                        if (this.response.error) {
+                            document.getElementById('loading').style.visibility = 'hidden';
+
+                            //TODO: handle this error
+                            return;
+                        }
+
+                        window.location.reload();
+                    });
+                }
+            }]);
+        }
+    };
+
+    var buttons = document.getElementById('mapContainer').getElementsByClassName('deleteButton');
+    for (var i = 0; i < buttons.length; i++) {
+        var button = buttons[i];
+
+        button.onclick = function () {
+            Maps.deleteMap(this.dataset.mapId, this.dataset.mapName);
+        };
+    }
+})();

public/static/js/profile.js

@@ -1,51 +0,0 @@
-(function () {
-    var form = document.getElementById('profileForm');
-
-    form.elements.password_new.onkeyup = function () {
-        MapGuesser.toggleDisableOnChange(this, form.elements.save);
-    };
-
-    form.elements.password_new_confirm.onkeyup = function () {
-        MapGuesser.toggleDisableOnChange(this, form.elements.save);
-    };
-
-    form.onsubmit = function (e) {
-        document.getElementById('loading').style.visibility = 'visible';
-
-        e.preventDefault();
-
-        var formData = new FormData(form);
-
-        MapGuesser.httpRequest('POST', form.action, function () {
-            document.getElementById('loading').style.visibility = 'hidden';
-
-            if (this.response.error) {
-                var errorText;
-                switch (this.response.error) {
-                    case 'password_not_match':
-                        errorText = 'The given current password is wrong.'
-                        break;
-                    case 'passwords_too_short':
-                        errorText = 'The given new password is too short. Please choose a password that is at least 6 characters long!'
-                        break;
-                    case 'passwords_not_match':
-                        errorText = 'The given new passwords do not match.'
-                        break;
-                }
-
-                var profileFormError = document.getElementById('profileFormError');
-                profileFormError.style.display = 'block';
-                profileFormError.innerHTML = errorText;
-
-                form.elements.password_new.select();
-
-                return;
-            }
-
-            document.getElementById('profileFormError').style.display = 'none';
-            form.reset();
-            form.elements.save.disabled = true;
-            form.elements.password_new.focus();
-        }, formData);
-    };
-})();

public/static/js/signup.js

@@ -1,47 +0,0 @@
-(function () {
-    var form = document.getElementById('signupForm');
-
-    form.onsubmit = function (e) {
-        document.getElementById('loading').style.visibility = 'visible';
-
-        e.preventDefault();
-
-        var formData = new FormData(form);
-
-        MapGuesser.httpRequest('POST', form.action, function () {
-            document.getElementById('loading').style.visibility = 'hidden';
-
-            if (this.response.error) {
-                var errorText;
-                switch (this.response.error) {
-                    case 'passwords_too_short':
-                        errorText = 'The given password is too short. Please choose a password that is at least 6 characters long!'
-                        break;
-                    case 'passwords_not_match':
-                        errorText = 'The given passwords do not match.'
-                        break;
-                    case 'user_found':
-                        errorText = 'There is a user already registered with the given email address. Please <a href="/login" title="Login">login here</a>!';
-                        break;
-                    case 'not_active_user_found':
-                        errorText = 'There is a user already registered with the given email address. Please check your email and click on the activation link!';
-                        break;
-                }
-
-                var signupFormError = document.getElementById('signupFormError');
-                signupFormError.style.display = 'block';
-                signupFormError.innerHTML = errorText;
-
-                form.elements.email.select();
-
-                return;
-            }
-
-            document.getElementById('signupFormError').style.display = 'none';
-            form.reset();
-            form.elements.email.focus();
-
-            MapGuesser.showModalWithContent('Sign up successful', 'Sign up was successful. Please check your email and click on the activation link to activate your account!');
-        }, formData);
-    };
-})();

scripts/deploy-to-multiple-worktrees.py

@@ -1,147 +0,0 @@
-#!/usr/bin/python3
-
-# Usage: ./deploy-to-multiple-worktrees.py REPO_PATH WORKTREE_DEVELOPMENT_PATH WORKTREE_PRODUCTION_PATH
-
-import sys
-import os
-import subprocess
-import re
-
-WORKTREE_REGEX = r"^worktree (.*)\nHEAD ([a-f0-9]*)\n(?:branch refs\/heads\/(.*)|detached)$"
-
-if len(sys.argv) < 4:
-    print("Usage: ./deploy-to-multiple-worktrees.py REPO_PATH WORKTREE_DEVELOPMENT_PATH WORKTREE_PRODUCTION_PATH")
-    exit(1)
-
-REPO = os.path.abspath(sys.argv[1])
-WORKTREE_DEVELOPMENT = os.path.abspath(sys.argv[2])
-WORKTREE_PRODUCTION = os.path.abspath(sys.argv[3])
-
-class Worktree:
-    def __init__(self, path, branch, revision, version):
-        self.path = path
-        self.branch = branch
-        self.revision = revision
-        self.version = version
-        self.newRevision = None
-        self.newVersion = None
-
-def getDataForWorktrees():
-    ret = subprocess.check_output(["git", "worktree", "list", "--porcelain"], cwd=REPO).decode().strip()
-    blocks = ret.split("\n\n")
-
-    worktrees = []
-
-    for block in blocks:
-        matches = re.search(WORKTREE_REGEX, block)
-
-        if matches:
-            path = matches.group(1)
-            revision = matches.group(2)
-            branch = matches.group(3)
-            version = getVersion(revision)
-
-            worktrees.append(Worktree(path, branch, revision, version))
-
-    return worktrees
-
-def findWorktree(path):
-    for worktree in worktrees:
-        if worktree.path == path:
-            return worktree
-
-    return None
-
-def getVersion(branch):
-    return subprocess.check_output(["git", "describe", "--tags", "--always", "--match", "Release_*", branch], cwd=REPO).decode().strip()
-
-def getRevisionForRef(ref):
-    return subprocess.check_output(["git", "rev-list", "-1", ref], cwd=REPO).decode().strip()
-
-def getLatestReleaseTag():
-    return subprocess.check_output(["git", "for-each-ref", "refs/tags/Release*", "--count=1", "--sort=-creatordate", "--format=%(refname:short)"], cwd=REPO).decode().strip()
-
-def updateRepoFromRemote():
-    subprocess.call(["git", "fetch", "origin", "--prune"], cwd=REPO)
-
-def checkoutWorktree(worktreePath, ref):
-    subprocess.call(["git", "checkout", "-f", ref], cwd=worktreePath)
-
-def cleanWorktree(worktreePath):
-    subprocess.call(["git", "clean", "-f", "-d"], cwd=worktreePath)
-
-def updateAppInWorktree(worktreePath):
-    subprocess.call([worktreePath + "/scripts/update.sh"], cwd=worktreePath)
-
-def updateAppVersionInWorktree(worktreePath):
-    subprocess.call([worktreePath + "/scripts/update-version.sh"], cwd=worktreePath)
-
-worktrees = getDataForWorktrees()
-
-updateRepoFromRemote()
-
-print("Repo is updated from origin")
-
-print("----------------------------------------------")
-print("----------------------------------------------")
-
-developmentWorktree = findWorktree(WORKTREE_DEVELOPMENT)
-
-developmentWorktree.newRevision = getRevisionForRef(developmentWorktree.branch)
-developmentWorktree.newVersion = getVersion(developmentWorktree.revision)
-
-print("DEVELOPMENT (" + developmentWorktree.path + ") is on branch " + developmentWorktree.branch)
-print(developmentWorktree.revision + " = " + developmentWorktree.branch + " (" + developmentWorktree.version + ")")
-print(developmentWorktree.newRevision + " = origin/" + developmentWorktree.branch + " (" + developmentWorktree.newVersion + ")")
-
-if developmentWorktree.revision != developmentWorktree.newRevision:
-    print("-> DEVELOPMENT (" + developmentWorktree.path + ") will be UPDATED")
-    print("----------------------------------------------")
-
-    checkoutWorktree(developmentWorktree.path, developmentWorktree.branch)
-    cleanWorktree(developmentWorktree.path)
-
-    print(developmentWorktree.path + " is checked out to " + developmentWorktree.branch + " and cleaned")
-
-    updateAppInWorktree(developmentWorktree.path)
-    updateAppVersionInWorktree(developmentWorktree.path)
-
-    print("MapGuesser is updated in " + developmentWorktree.path)
-elif developmentWorktree.version != developmentWorktree.newVersion:
-    print("-> DEVELOPMENT " + developmentWorktree.path + "'s version info will be UPDATED")
-
-    updateAppVersionInWorktree(developmentWorktree.path)
-
-    print("MapGuesser version is updated in " + developmentWorktree.path)
-else:
-    print("-> DEVELOPMENT (" + developmentWorktree.path + ") WON'T be updated")
-
-print("----------------------------------------------")
-print("----------------------------------------------")
-
-productionWorktree = findWorktree(WORKTREE_PRODUCTION)
-
-productionWorktree.newVersion = getLatestReleaseTag()
-productionWorktree.newRevision = getRevisionForRef(productionWorktree.newVersion)
-
-print("PRODUCTION (" + productionWorktree.path + ")")
-print(productionWorktree.revision + " = " + productionWorktree.version)
-print(productionWorktree.newRevision + " = " + productionWorktree.newVersion)
-
-if productionWorktree.revision != productionWorktree.newRevision:
-    print("-> PRODUCTION (" + productionWorktree.path + ") will be UPDATED")
-
-    checkoutWorktree(productionWorktree.path, productionWorktree.newRevision)
-    cleanWorktree(productionWorktree.path)
-
-    print(productionWorktree.path + " is checked out to " + productionWorktree.newRevision + " and cleaned")
-
-    updateAppInWorktree(productionWorktree.path)
-    updateAppVersionInWorktree(productionWorktree.path)
-
-    print("MapGuesser is updated in " + productionWorktree.path)
-else:
-    print("-> PRODUCTION (" + productionWorktree.path + ") WON'T be updated")
-
-print("----------------------------------------------")
-print("----------------------------------------------")

scripts/install.sh

@@ -1,26 +0,0 @@
-#!/bin/bash
-
-ROOT_DIR=$(dirname $(readlink -f "$0"))/..
-
-. ${ROOT_DIR}/.env
-
-if [ -f ${ROOT_DIR}/installed ]; then
-    echo "MapGuesser is already installed! To force reinstall, delete file 'installed' from the root directory!"
-    exit 1
-fi
-
-echo "Installing Yarn packages..."
-(cd ${ROOT_DIR}/public/static && yarn install)
-
-echo "Installing MapGuesser DB..."
-mysql --host=${DB_HOST} --user=${DB_USER} --password=${DB_PASSWORD} ${DB_NAME} < ${ROOT_DIR}/db/mapguesser.sql
-
-echo "Migrating DB..."
-(cd ${ROOT_DIR} && ./mapg migrate)
-
-if [ -z "${DEV}" ] || [ "${DEV}" -eq "0" ]; then
-    echo "Minifying JS, CSS and SVG files..."
-    ${ROOT_DIR}/scripts/minify.sh
-fi
-
-touch ${ROOT_DIR}/installed

scripts/minify.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-
-ROOT_DIR=$(dirname $(readlink -f "$0"))/..
-
-. ${ROOT_DIR}/.env
-
-find ${ROOT_DIR}/public/static/js -type f -iname '*.js' -exec uglifyjs {} -c -m -o {} \;
-
-find ${ROOT_DIR}/public/static/css -type f -iname '*.css' -exec cleancss {} -o {} \;
-
-find ${ROOT_DIR}/public/static/img -type f -iname '*.svg' -exec svgo {} -o {} \;

scripts/run-sql.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+
+if [ "$#" -lt 1 ]; then
+    echo "Usage: $0 <sql_file>"
+    exit 1
+fi
+
+SQL_FILE=$1
+
+ROOT_DIR=$(dirname $(readlink -f "$0"))/..
+
+. ${ROOT_DIR}/.env
+
+if [ -z "${DEV}" ] || [ "${DEV}" -eq "0" ]; then
+    echo "This script can only be used in DEV mode!"
+    exit 1
+fi
+
+echo "Running SQL on DB..."
+mysql --host=${DB_HOST} --user=${DB_USER} --password=${DB_PASSWORD} ${DB_NAME} < ${SQL_FILE}

scripts/update-version.sh

@@ -1,17 +0,0 @@
-#!/bin/bash
-
-ROOT_DIR=$(dirname $(readlink -f "$0"))/..
-
-. ${ROOT_DIR}/.env
-
-cd ${ROOT_DIR}
-
-echo "Updating version info..."
-
-VERSION=$(git describe --tags --always --match "Release_*" HEAD)
-REVISION=$(git rev-parse --short HEAD)
-REVISION_DATE=$(git show -s --format=%aI HEAD)
-
-sed -i -E "s/const VERSION = '(.*)';/const VERSION = '${VERSION}';/" main.php
-sed -i -E "s/const REVISION = '(.*)';/const REVISION = '${REVISION}';/" main.php
-sed -i -E "s/const REVISION_DATE = '(.*)';/const REVISION_DATE = '${REVISION_DATE}';/" main.php

scripts/update.sh

@@ -1,19 +0,0 @@
-#!/bin/bash
-
-ROOT_DIR=$(dirname $(readlink -f "$0"))/..
-
-. ${ROOT_DIR}/.env
-
-echo "Installing Composer packages..."
-(cd ${ROOT_DIR} && composer install)
-
-echo "Installing Yarn packages..."
-(cd ${ROOT_DIR}/public/static && yarn install)
-
-echo "Migrating DB..."
-(cd ${ROOT_DIR} && ./mapg migrate)
-
-if [ -z "${DEV}" ] || [ "${DEV}" -eq "0" ]; then
-    echo "Minifying JS, CSS and SVG files..."
-    ${ROOT_DIR}/scripts/minify.sh
-fi

src/Cli/AddUserCommand.php

@@ -1,7 +1,7 @@
 <?php namespace MapGuesser\Cli;
 
-use MapGuesser\Database\Query\Modify;
-use MapGuesser\Model\User;
+use DateTime;
+use MapGuesser\PersistentData\Model\User;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
@@ -9,31 +9,31 @@ use Symfony\Component\Console\Output\OutputInterface;
 
 class AddUserCommand extends Command
 {
-    public function configure()
+    public function configure(): void
     {
         $this->setName('user:add')
             ->setDescription('Adding of user.')
             ->addArgument('email', InputArgument::REQUIRED, 'Email of user')
+            ->addArgument('username', InputArgument::REQUIRED, 'Username of user')
             ->addArgument('password', InputArgument::REQUIRED, 'Password of user')
             ->addArgument('type', InputArgument::OPTIONAL, 'Type of user');;
     }
 
     public function execute(InputInterface $input, OutputInterface $output): int
     {
-        $user = new User([
-            'email' => $input->getArgument('email'),
-        ]);
-
+        $user = new User();
+        $user->setEmail($input->getArgument('email'));
+        $user->setUsername($input->getArgument('username'));
         $user->setPlainPassword($input->getArgument('password'));
+        $user->setActive(true);
+        $user->setCreatedDate(new DateTime());
 
-        if ($input->hasArgument('type')) {
+        if ($input->hasArgument('type') && $input->getArgument('type') !== null) {
             $user->setType($input->getArgument('type'));
         }
 
         try {
-            $modify = new Modify(\Container::$dbConnection, 'users');
-            $modify->fill($user->toArray());
-            $modify->save();
+            \Container::$persistentDataManager->saveToDb($user);
         } catch (\Exception $e) {
             $output->writeln('<error>Adding user failed!</error>');
             $output->writeln('');

src/Cli/LinkViewCommand.php

@@ -0,0 +1,69 @@
+<?php namespace MapGuesser\Cli;
+
+use FilesystemIterator;
+use SokoWeb\View\Linker;
+use RecursiveDirectoryIterator;
+use RecursiveIteratorIterator;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class LinkViewCommand extends Command
+{
+    public function configure(): void
+    {
+        $this->setName('view:link')
+            ->setDescription('Linking of views.')
+            ->addArgument('view', InputArgument::OPTIONAL, 'View file to be linked.');
+    }
+
+    public function execute(InputInterface $input, OutputInterface $output): int
+    {
+        $views = [];
+
+        $view = $input->getArgument('view');
+
+        if ($view !== null) {
+            $views[] = $view;
+        } else {
+            $folder = ROOT . '/views';
+            $folderLength = strlen($folder) + 1;
+
+            $iterator = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($folder, FilesystemIterator::SKIP_DOTS), RecursiveIteratorIterator::SELF_FIRST);
+
+            foreach ($iterator as $file) {
+                if ($file->isDir() || $file->getExtension() !== 'php') {
+                    continue;
+                }
+
+                $view = substr($file->getPath(), $folderLength) . '/' . $file->getBasename('.php');
+
+                if (strpos($view, 'templates') === 0 || strpos($view, 'tests') === 0) {
+                    continue;
+                }
+
+                $views[] = $view;
+            }
+        }
+
+        try {
+            foreach ($views as $view) {
+                $generator = new Linker($view);
+                $generator->generate();
+            }
+        } catch (\Exception $e) {
+            $output->writeln('<error>Linking view(s) failed!</error>');
+            $output->writeln('');
+
+            $output->writeln((string) $e);
+            $output->writeln('');
+
+            return 1;
+        }
+
+        $output->writeln('<info>View(s) successfully linked!</info>');
+
+        return 0;
+    }
+}

src/Cli/MaintainDatabaseCommand.php

@@ -0,0 +1,123 @@
+<?php namespace MapGuesser\Cli;
+
+use DateTime;
+use SokoWeb\Database\Query\Modify;
+use SokoWeb\Database\Query\Select;
+use SokoWeb\Interfaces\Database\IResultSet;
+use MapGuesser\Repository\MultiRoomRepository;
+use MapGuesser\Repository\UserConfirmationRepository;
+use MapGuesser\Repository\UserPasswordResetterRepository;
+use MapGuesser\Repository\UserPlayedPlaceRepository;
+use MapGuesser\Repository\UserRepository;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+class MaintainDatabaseCommand extends Command
+{
+    private UserRepository $userRepository;
+
+    private UserConfirmationRepository $userConfirmationRepository;
+
+    private UserPasswordResetterRepository $userPasswordResetterRepository;
+
+    private MultiRoomRepository $multiRoomRepository;
+
+    private UserPlayedPlaceRepository $userPlayedPlaceRepository;
+
+    public function __construct()
+    {
+        parent::__construct();
+
+        $this->userRepository = new UserRepository();
+        $this->userConfirmationRepository = new UserConfirmationRepository();
+        $this->userPasswordResetterRepository = new UserPasswordResetterRepository();
+        $this->multiRoomRepository = new MultiRoomRepository();
+        $this->userPlayedPlaceRepository = new UserPlayedPlaceRepository();
+    }
+
+    public function configure(): void
+    {
+        $this->setName('db:maintain')
+            ->setDescription('Maintain database.');
+    }
+
+    public function execute(InputInterface $input, OutputInterface $output): int
+    {
+        try {
+            $this->deleteInactiveExpiredUsers();
+            $this->deleteExpiredPasswordResetters();
+            $this->deleteExpiredRooms();
+            $this->deleteExpiredSessions();
+        } catch (\Exception $e) {
+            $output->writeln('<error>Maintenance failed!</error>');
+            $output->writeln('');
+
+            $output->writeln((string) $e);
+            $output->writeln('');
+
+            return 1;
+        }
+
+        $output->writeln('<info>Maintenance was successful!</info>');
+        $output->writeln('');
+
+        return 0;
+    }
+
+    private function deleteInactiveExpiredUsers(): void
+    {
+        \Container::$dbConnection->startTransaction();
+
+        foreach ($this->userRepository->getAllInactiveExpired() as $user) {
+            //TODO: these can be in some wrapper class
+            $userConfirmation = $this->userConfirmationRepository->getByUser($user);
+            if ($userConfirmation !== null) {
+                \Container::$persistentDataManager->deleteFromDb($userConfirmation);
+            }
+
+            $userPasswordResetter = $this->userPasswordResetterRepository->getByUser($user);
+            if ($userPasswordResetter !== null) {
+                \Container::$persistentDataManager->deleteFromDb($userPasswordResetter);
+            }
+
+            foreach ($this->userPlayedPlaceRepository->getAllByUser($user) as $userPlayedPlace) {
+                \Container::$persistentDataManager->deleteFromDb($userPlayedPlace);
+            }
+
+            \Container::$persistentDataManager->deleteFromDb($user);
+        }
+
+        \Container::$dbConnection->commit();
+    }
+
+    private function deleteExpiredPasswordResetters(): void
+    {
+        foreach ($this->userPasswordResetterRepository->getAllExpired() as $passwordResetter) {
+            \Container::$persistentDataManager->deleteFromDb($passwordResetter);
+        }
+    }
+
+    private function deleteExpiredRooms(): void
+    {
+        foreach ($this->multiRoomRepository->getAllExpired() as $multiRoom) {
+            \Container::$persistentDataManager->deleteFromDb($multiRoom);
+        }
+    }
+
+    private function deleteExpiredSessions(): void
+    {
+        //TODO: model may be used for sessions too
+        $select = new Select(\Container::$dbConnection, 'sessions');
+        $select->columns(['id']);
+        $select->where('updated', '<', (new DateTime('-7 days'))->format('Y-m-d H:i:s'));
+
+        $result = $select->execute();
+
+        while ($session = $result->fetch(IResultSet::FETCH_ASSOC)) {
+            $modify = new Modify(\Container::$dbConnection, 'sessions');
+            $modify->setId($session['id']);
+            $modify->delete();
+        }
+    }
+}

src/Cli/MigrateDatabaseCommand.php

@@ -1,17 +1,17 @@
 <?php namespace MapGuesser\Cli;
 
-use MapGuesser\Database\Query\Modify;
-use MapGuesser\Database\Query\Select;
-use MapGuesser\Interfaces\Database\IResultSet;
+use SokoWeb\Database\Query\Modify;
+use SokoWeb\Database\Query\Select;
+use SokoWeb\Interfaces\Database\IResultSet;
 use Symfony\Component\Console\Command\Command;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
 
-class DatabaseMigration extends Command
+class MigrateDatabaseCommand extends Command
 {
-    public function configure()
+    public function configure(): void
     {
-        $this->setName('migrate')
+        $this->setName('db:migrate')
             ->setDescription('Migration of database changes.');
     }
 
@@ -19,6 +19,8 @@ class DatabaseMigration extends Command
     {
         $db = \Container::$dbConnection;
 
+        $this->createBaseDb();
+
         $db->startTransaction();
 
         $success = [];
@@ -62,10 +64,8 @@ class DatabaseMigration extends Command
         return 0;
     }
 
-    private function readDir(string $type): array
+    private function createBaseDb()
     {
-        $done = [];
-
         $migrationTableExists = \Container::$dbConnection->query('SELECT count(*)
             FROM information_schema.tables
             WHERE table_schema = \'' . $_ENV['DB_NAME'] . '\'
@@ -73,21 +73,34 @@ class DatabaseMigration extends Command
             ->fetch(IResultSet::FETCH_NUM)[0];
 
         if ($migrationTableExists != 0) {
-            $select = new Select(\Container::$dbConnection, 'migrations');
-            $select->columns(['migration']);
-            $select->where('type', '=', $type);
-            $select->orderBy('migration');
+            return;
+        }
 
-            $result = $select->execute();
+        \Container::$dbConnection->multiQuery(file_get_contents(ROOT . '/database/mapguesser.sql'));
+    }
 
-            while ($migration = $result->fetch(IResultSet::FETCH_ASSOC)) {
-                $done[] = $migration['migration'];
-            }
+    private function readDir(string $type): array
+    {
+        $done = [];
+
+        $select = new Select(\Container::$dbConnection, 'migrations');
+        $select->columns(['migration']);
+        $select->where('type', '=', $type);
+        $select->orderBy('migration');
+
+        $result = $select->execute();
+
+        while ($migration = $result->fetch(IResultSet::FETCH_ASSOC)) {
+            $done[] = $migration['migration'];
         }
 
         $path = ROOT . '/database/migrations/' . $type;
         $dir = opendir($path);
 
+        if ($dir === false) {
+            throw new \Exception('Cannot open dir: ' . $path);
+        }
+
         $files = [];
         while ($file = readdir($dir)) {
             $filePath = $path . '/' . $file;

src/Controller/GameController.php

@@ -1,54 +1,298 @@
 <?php namespace MapGuesser\Controller;
 
-use MapGuesser\Interfaces\Request\IRequest;
-use MapGuesser\Util\Geo\Bounds;
-use MapGuesser\Response\HtmlContent;
-use MapGuesser\Response\JsonContent;
-use MapGuesser\Interfaces\Response\IContent;
+use DateTime;
+use SokoWeb\Interfaces\Authentication\IAuthenticationRequired;
+use SokoWeb\Response\HtmlContent;
+use SokoWeb\Response\JsonContent;
+use SokoWeb\Interfaces\Response\IContent;
+use SokoWeb\Interfaces\Response\IRedirect;
+use MapGuesser\Multi\MultiConnector;
+use MapGuesser\PersistentData\Model\Challenge;
+use MapGuesser\PersistentData\Model\MultiRoom;
+use MapGuesser\PersistentData\Model\PlaceInChallenge;
+use MapGuesser\PersistentData\Model\UserInChallenge;
+use MapGuesser\PersistentData\Model\User;
+use MapGuesser\Repository\ChallengeRepository;
 use MapGuesser\Repository\MapRepository;
+use MapGuesser\Repository\MultiRoomRepository;
+use MapGuesser\Repository\PlaceRepository;
+use MapGuesser\Repository\UserInChallengeRepository;
+use SokoWeb\Response\Redirect;
 
-class GameController
+class GameController implements IAuthenticationRequired
 {
-    private IRequest $request;
+    const NUMBER_OF_ROUNDS = 5;
+
+    private MultiConnector $multiConnector;
+
+    private MultiRoomRepository $multiRoomRepository;
 
     private MapRepository $mapRepository;
 
-    public function __construct(IRequest $request)
+    private PlaceRepository $placeRepository;
+
+    private ChallengeRepository $challengeRepository;
+
+    private UserInChallengeRepository $userInChallengeRepository;
+
+    public function __construct()
     {
-        $this->request = $request;
+        $this->multiConnector = new MultiConnector();
+        $this->multiRoomRepository = new MultiRoomRepository();
         $this->mapRepository = new MapRepository();
+        $this->placeRepository = new PlaceRepository();
+        $this->challengeRepository = new ChallengeRepository();
+        $this->userInChallengeRepository = new UserInChallengeRepository();
+    }
+
+    public function isAuthenticationRequired(): bool
+    {
+        return empty($_ENV['ENABLE_GAME_FOR_GUESTS']);
     }
 
     public function getGame(): IContent
     {
-        $mapId = (int) $this->request->query('mapId');
-        $data = $this->prepareGame($mapId);
-        return new HtmlContent('game', $data);
+        $mapId = (int) \Container::$request->query('mapId');
+
+        return new HtmlContent('game', ['mapId' => $mapId]);
     }
 
-    public function getGameJson(): IContent
-    {
-        $mapId = (int) $this->request->query('mapId');
-        $data = $this->prepareGame($mapId);
-        return new JsonContent($data);
-    }
-
-    private function prepareGame(int $mapId)
+    public function getNewMultiGame(): IRedirect
     {
+        $mapId = (int) \Container::$request->query('mapId');
         $map = $this->mapRepository->getById($mapId);
+        $roomId = bin2hex(random_bytes(3));
+        $token = $this->getMultiToken($roomId);
 
-        $bounds = Bounds::createDirectly($map['bound_south_lat'], $map['bound_west_lng'], $map['bound_north_lat'], $map['bound_east_lng']);
+        $room = new MultiRoom();
+        $room->setRoomId($roomId);
+        $room->setStateArray([
+            'mapId' => $mapId,
+            'area' => $map->getArea(),
+            'rounds' => [],
+            'currentRound' => -1
+        ]);
+        $room->setMembersArray(['owner' => $token, 'all' => []]);
+        $room->setUpdatedDate(new DateTime());
 
-        $session = $this->request->session();
+        \Container::$persistentDataManager->saveToDb($room);
+
+        $this->multiConnector->sendMessage('create_room', ['roomId' => $roomId]);
+
+        return new Redirect(
+            \Container::$routeCollection
+                ->getRoute('multiGame')
+                ->generateLink(['roomId' => $roomId]),
+            IRedirect::TEMPORARY
+        );
+    }
+
+    public function getMultiGame(): IContent
+    {
+        $roomId = \Container::$request->query('roomId');
+
+        return new HtmlContent('game', ['roomId' => $roomId]);
+    }
+
+    public function getChallenge(): IContent
+    {
+        $challengeToken = \Container::$request->query('challengeToken');
+
+        return new HtmlContent('game', ['challengeToken' => $challengeToken]);
+    }
+
+    public function createNewChallenge(): IContent
+    {
+        // create Challenge
+        do {
+            // initiliaze or if a challenge with the same token already exists
+            $challengeToken = mt_rand();
+        } while ($this->challengeRepository->getByToken($challengeToken));
+
+        $challenge = new Challenge();
+        $challenge->setToken($challengeToken);
+        $challenge->setCreatedDate(new DateTime());
+
+        if (\Container::$request->post('timerEnabled') !== null && \Container::$request->post('timeLimit') !== null) {
+            $challenge->setTimeLimit(\Container::$request->post('timeLimit'));
+        }
+        if (\Container::$request->post('timeLimitType') !== null) {
+            $challenge->setTimeLimitType(\Container::$request->post('timeLimitType'));
+        }
+        if (\Container::$request->post('noMove') !== null) {
+            $challenge->setNoMove(true);
+        }
+        if (\Container::$request->post('noPan') !== null) {
+            $challenge->setNoPan(true);
+        }
+        if (\Container::$request->post('noZoom') !== null) {
+            $challenge->setNoZoom(true);
+        }
+
+        \Container::$persistentDataManager->saveToDb($challenge);
+
+        // save owner/creator
+
+        $session = \Container::$request->session();
+        $userId = $session->get('userId');
+
+        $userInChallenge = new UserInChallenge();
+        $userInChallenge->setUserId($userId);
+        $userInChallenge->setChallenge($challenge);
+        $userInChallenge->setTimeLeft($challenge->getTimeLimit());
+        $userInChallenge->setIsOwner(true);
+
+        \Container::$persistentDataManager->saveToDb($userInChallenge);
+
+        // select places
+
+        $mapId = (int) \Container::$request->post('mapId');
+        // $map = $this->mapRepository->getById($mapId);
+
+        $places = $this->placeRepository->getRandomNPlaces($mapId, static::NUMBER_OF_ROUNDS, $userId);
+
+        $round = 0;
+        foreach ($places as $place) {
+            $placeInChallenge = new PlaceInChallenge();
+            $placeInChallenge->setPlace($place);
+            $placeInChallenge->setChallenge($challenge);
+            $placeInChallenge->setRound($round++);
+            \Container::$persistentDataManager->saveToDb($placeInChallenge);
+        }
+
+        return new JsonContent(['challengeToken' => dechex($challengeToken)]);
+    }
+
+    public function prepareGame(): IContent
+    {
+        $mapId = (int) \Container::$request->query('mapId');
+        $map = $this->mapRepository->getById($mapId);
+        $session = \Container::$request->session();
 
         if (!($state = $session->get('state')) || $state['mapId'] !== $mapId) {
             $session->set('state', [
                 'mapId' => $mapId,
-                'area' => $map['area'],
-                'rounds' => []
+                'area' => $map->getArea(),
+                'rounds' => [],
+                'currentRound' => -1
             ]);
+        } else { // update the area of the map in the session in any case
+            $state['area'] = $map->getArea();
+            $session->set('state', $state);
         }
 
-        return ['mapId' => $mapId, 'mapName' => $map['name'], 'bounds' => $bounds->toArray()];
+        return new JsonContent([
+            'mapId' => $mapId,
+            'mapName' => $map->getName(),
+            'bounds' => $map->getBounds()->toArray()
+        ]);
+    }
+
+    public function prepareMultiGame(): IContent
+    {
+        /**
+         * @var User|null $user
+         */
+        $user = \Container::$request->user();
+        if ($user === null)
+        {
+            return new JsonContent(['error' => 'anonymous_user']);
+        }
+
+        $roomId = \Container::$request->query('roomId');
+
+        $room = $this->multiRoomRepository->getByRoomId($roomId);
+
+        if (!isset($room)) {
+            return new JsonContent(['error' => 'game_not_found']);
+        }
+
+        $state = $room->getStateArray();
+        $map = $this->mapRepository->getById($state['mapId']);
+        $token = $this->getMultiToken($roomId);
+
+        $members = $room->getMembersArray();
+
+        if (!in_array($token, $members['all'])) {
+            if ($state['currentRound'] >= 0) {
+                return new JsonContent(['error' => 'game_already_started']);
+            }
+
+            $members['all'][] = $token;
+        }
+
+        $room->setMembersArray($members);
+        $room->setUpdatedDate(new DateTime());
+
+        \Container::$persistentDataManager->saveToDb($room);
+
+        $this->multiConnector->sendMessage('join_room', [
+            'roomId' => $roomId,
+            'token' => $token,
+            'userName' => $user->getDisplayName()
+        ]);
+
+        return new JsonContent([
+            'roomId' => $roomId,
+            'token' => $token,
+            'owner' => $members['owner'] == $token,
+            'mapId' => $state['mapId'],
+            'mapName' => $map->getName(),
+            'bounds' => $map->getBounds()->toArray()
+        ]);
+    }
+
+    public function prepareChallenge(): IContent
+    {
+        $challengeToken_str = \Container::$request->query('challengeToken');
+        $session = \Container::$request->session();
+        $userId = $session->get('userId');
+
+        if (!isset($userId))
+        {
+            return new JsonContent(['error' => 'anonymous_user']);
+        }
+
+        $challenge = $this->challengeRepository->getByTokenStr($challengeToken_str);
+
+        if (!isset($challenge))
+        {
+            return new JsonContent(['error' => 'game_not_found']);
+        }
+
+        if (!$this->userInChallengeRepository->isUserParticipatingInChallenge($userId, $challenge)) {
+            // new player is joining
+            $userInChallenge = new UserInChallenge();
+            $userInChallenge->setUserId($userId);
+            $userInChallenge->setChallenge($challenge);
+            $userInChallenge->setTimeLeft($challenge->getTimeLimit());
+            \Container::$persistentDataManager->saveToDb($userInChallenge);
+        }
+
+        $map = $this->mapRepository->getByChallenge($challenge);
+
+        return new JsonContent([
+            'mapId' => $map->getId(),
+            'mapName' => $map->getName(),
+            'bounds' => $map->getBounds()->toArray()
+        ]);
+    }
+
+    private function getMultiToken(string $roomId): string
+    {
+        $session = \Container::$request->session();
+
+        if (!($multiState = $session->get('multiState')) || $multiState['roomId'] !== $roomId) {
+            $token = bin2hex(random_bytes(16));
+
+            $session->set('multiState', [
+                'roomId' => $roomId,
+                'token' => $token
+            ]);
+        } else {
+            $token = $multiState['token'];
+        }
+
+        return $token;
     }
 }

src/Controller/GameFlowController.php

@@ -1,119 +1,456 @@
 <?php namespace MapGuesser\Controller;
 
-use MapGuesser\Interfaces\Request\IRequest;
+use DateTime;
+use SokoWeb\Interfaces\Authentication\IAuthenticationRequired;
 use MapGuesser\Util\Geo\Position;
-use MapGuesser\Response\JsonContent;
-use MapGuesser\Interfaces\Response\IContent;
+use SokoWeb\Response\JsonContent;
+use SokoWeb\Interfaces\Response\IContent;
+use MapGuesser\Multi\MultiConnector;
+use MapGuesser\PersistentData\Model\Challenge;
+use MapGuesser\PersistentData\Model\Guess;
+use MapGuesser\PersistentData\Model\Map;
+use MapGuesser\PersistentData\Model\Place;
+use MapGuesser\PersistentData\Model\PlaceInChallenge;
+use MapGuesser\PersistentData\Model\User;
+use MapGuesser\PersistentData\Model\UserPlayedPlace;
+use MapGuesser\Repository\GuessRepository;
+use MapGuesser\Repository\MultiRoomRepository;
+use MapGuesser\Repository\PlaceInChallengeRepository;
 use MapGuesser\Repository\PlaceRepository;
+use MapGuesser\Repository\UserInChallengeRepository;
+use MapGuesser\Repository\UserPlayedPlaceRepository;
 
-class GameFlowController
+class GameFlowController implements IAuthenticationRequired
 {
     const NUMBER_OF_ROUNDS = 5;
     const MAX_SCORE = 1000;
 
-    private IRequest $request;
+    private MultiConnector $multiConnector;
+
+    private MultiRoomRepository $multiRoomRepository;
 
     private PlaceRepository $placeRepository;
 
-    public function __construct(IRequest $request)
+    private UserPlayedPlaceRepository $userPlayedPlaceRepository;
+
+    private UserInChallengeRepository $userInChallengeRepository;
+
+    private PlaceInChallengeRepository $placeInChallengeRepository;
+
+    private GuessRepository $guessRepository;
+
+    public function __construct()
     {
-        $this->request = $request;
+        $this->multiConnector = new MultiConnector();
+        $this->multiRoomRepository = new MultiRoomRepository();
         $this->placeRepository = new PlaceRepository();
+        $this->userPlayedPlaceRepository = new UserPlayedPlaceRepository();
+        $this->userInChallengeRepository = new UserInChallengeRepository();
+        $this->placeInChallengeRepository = new PlaceInChallengeRepository();
+        $this->guessRepository = new GuessRepository();
     }
 
-    public function getNewPlace(): IContent
+    public function isAuthenticationRequired(): bool
     {
-        $mapId = (int) $this->request->query('mapId');
+        return empty($_ENV['ENABLE_GAME_FOR_GUESTS']);
+    }
 
-        $session = $this->request->session();
+    public function initialData(): IContent
+    {
+        $mapId = (int) \Container::$request->query('mapId');
+        $session = \Container::$request->session();
 
         if (!($state = $session->get('state')) || $state['mapId'] !== $mapId) {
-            $data = ['error' => 'no_session_found'];
-            return new JsonContent($data);
+            return new JsonContent(['error' => 'no_session_found']);
         }
 
-        if (count($state['rounds']) === 0) {
-            $place = $this->placeRepository->getForMapWithValidPano($mapId);
-            $state['rounds'][] = $place;
+        if (!isset($state['currentRound']) || $state['currentRound'] == -1 || $state['currentRound'] >= static::NUMBER_OF_ROUNDS) {
+            $this->startNewGame($state, $mapId);
             $session->set('state', $state);
+        }
 
-            $data = ['panoId' => $place['panoId']];
-        } else {
-            $rounds = count($state['rounds']);
-            $last = $state['rounds'][$rounds - 1];
+        $response = [];
 
-            $history = [];
-            for ($i = 0; $i < $rounds - 1; ++$i) {
-                $round = $state['rounds'][$i];
-                $history[] = [
-                    'position' => $round['position']->toArray(),
+        $last = $state['rounds'][$state['currentRound']];
+        $response['place'] = [
+            'panoId' => $last['panoId'],
+            'pov' => $last['pov']->toArray()
+        ];
+
+        $response['history'] = [];
+        for ($i = 0; $i < $state['currentRound']; ++$i) {
+            $round = $state['rounds'][$i];
+            $response['history'][] = [
+                'position' => $round['position']->toArray(),
+                'result' => [
                     'guessPosition' => $round['guessPosition']->toArray(),
                     'distance' => $round['distance'],
                     'score' => $round['score']
-                ];
-            }
-
-            $data = [
-                'history' => $history,
-                'panoId' => $last['panoId']
+                ]
             ];
         }
 
-        return new JsonContent($data);
+        return new JsonContent($response);
     }
 
-    public function evaluateGuess(): IContent
+    public function multiInitialData(): IContent
     {
-        $mapId = (int) $this->request->query('mapId');
+        $roomId = \Container::$request->query('roomId');
+        $session = \Container::$request->session();
 
-        $session = $this->request->session();
-
-        if (!($state = $session->get('state')) || $state['mapId'] !== $mapId) {
-            $data = ['error' => 'no_session_found'];
-            return new JsonContent($data);
+        if (!($multiState = $session->get('multiState')) || $multiState['roomId'] !== $roomId) {
+            return new JsonContent(['error' => 'no_session_found']);
         }
 
-        $last = $state['rounds'][count($state['rounds']) - 1];
+        $room = $this->multiRoomRepository->getByRoomId($roomId);
+        $state = $room->getStateArray();
+        $members = $room->getMembersArray();
 
-        $position = $last['position'];
-        $guessPosition = new Position((float) $this->request->post('lat'), (float) $this->request->post('lng'));
+        if ($members['owner'] !== $multiState['token']) {
+            return new JsonContent(['error' => 'not_owner_of_room']);
+        }
 
-        $distance = $this->calculateDistance($position, $guessPosition);
-        $score = $this->calculateScore($distance, $state['area']);
+        if ($state['currentRound'] == -1 || $state['currentRound'] >= static::NUMBER_OF_ROUNDS - 1) {
+            $this->startNewGame($state, $state['mapId']);
+            $room->setStateArray($state);
+            $room->setUpdatedDate(new DateTime());
+            \Container::$persistentDataManager->saveToDb($room);
+        }
 
-        $last['guessPosition'] = $guessPosition;
-        $last['distance'] = $distance;
-        $last['score'] = $score;
-        $state['rounds'][count($state['rounds']) - 1] = $last;
+        $places = [];
+        foreach ($state['rounds'] as $round) {
+            $places[] = [
+                'position' => $round['position']->toArray(),
+                'panoId' => $round['panoId'],
+                'pov' => $round['pov']->toArray()
+            ];
+        }
 
-        if (count($state['rounds']) < static::NUMBER_OF_ROUNDS) {
-            $exclude = [];
+        $this->multiConnector->sendMessage('start_game', ['roomId' => $roomId, 'places' => $places]);
 
-            foreach ($state['rounds'] as $round) {
-                $exclude = array_merge($exclude, $round['placesWithoutPano'], [$round['placeId']]);
+        return new JsonContent(['ok' => true]);
+    }
+
+    private function prepareChallengeResponse(int $userId, Challenge $challenge, int $currentRound, bool $withHistory = false): array
+    {
+        $currentPlace = $this->placeRepository->getByRoundInChallenge($challenge, $currentRound);
+
+        // if the last round was played ($currentPlace == null) or history is explicitly requested (for initializing)
+        if (!isset($currentPlace) || $withHistory) {
+
+            $withRelations = ['user', 'place_in_challange', 'place'];
+            foreach ($this->guessRepository->getAllInChallenge($challenge, $withRelations) as $guess) {
+                $round = $guess->getPlaceInChallenge()->getRound();
+
+                if ($guess->getUser()->getId() === $userId) {
+                    $response['history'][$round]['position'] =
+                            $guess->getPlaceInChallenge()->getPlace()->getPosition()->toArray();
+                    $response['history'][$round]['result'] = [
+                            'guessPosition' => $guess->getPosition()->toArray(),
+                            'distance' => $guess->getDistance(),
+                            'score' => $guess->getScore()
+                    ];
+                } else {
+                    $response['history'][$round]['allResults'][] = [
+                        'userName' => $guess->getUser()->getDisplayName(),
+                        'guessPosition' => $guess->getPosition()->toArray(),
+                        'distance' => $guess->getDistance(),
+                        'score' => $guess->getScore()
+                    ];
+                }
             }
 
-            $place = $this->placeRepository->getForMapWithValidPano($mapId, $exclude);
-            $state['rounds'][] = $place;
-            $session->set('state', $state);
+            // setting default values for rounds without guesses (because of timeout)
+            for ($i = 0; $i < $currentRound; ++$i) {
+                if (!isset($response['history'][$i]) || !isset($response['history'][$i]['result'])) {
+                    $response['history'][$i]['result'] = [
+                            'guessPosition' => null,
+                            'distance' => null,
+                            'score' => 0
+                    ];
 
-            $panoId = $place['panoId'];
-        } else {
-            $state['rounds'] = [];
-            $session->set('state', $state);
+                    $response['history'][$i]['position'] =
+                            $this->placeRepository->getByRoundInChallenge($challenge, $i)->getPosition()->toArray();
+                }
+            }
 
-            $panoId = null;
+            $response['history']['length'] = $currentRound;
         }
 
-        $data = [
-            'result' => [
-                'position' => $position->toArray(),
-                'distance' => $distance,
-                'score' => $score
-            ],
-            'panoId' => $panoId
+        if (!isset($currentPlace)) { // game finished
+            $response['finished'] = true;
+        } else { // continue game
+            $response['place'] = [
+                'panoId' => $currentPlace->getPanoIdCached(),
+                'pov' => $currentPlace->getPov()->toArray()
+            ];
+
+            $prevRound = $currentRound - 1;
+            if ($prevRound >= 0) {
+                foreach ($this->guessRepository->getAllInChallengeByRound($prevRound, $challenge, ['user']) as $guess) {
+                    if ($guess->getUser()->getId() != $userId) {
+                        $response['allResults'][] = [
+                            'userName' => $guess->getUser()->getDisplayName(),
+                            'guessPosition' => $guess->getPosition()->toArray(),
+                            'distance' => $guess->getDistance(),
+                            'score' => $guess->getScore()
+                        ];
+                    }
+                }
+            }
+        }
+
+        $response['restrictions'] = [
+            'timeLimit' => $challenge->getTimeLimit() * 1000,
+            'timeLimitType' => $challenge->getTimeLimitType(),
+            'noMove' => $challenge->getNoMove(),
+            'noPan' => $challenge->getNoPan(),
+            'noZoom' => $challenge->getNoZoom()
         ];
-        return new JsonContent($data);
+
+        return $response;
+    }
+
+    public function challengeInitialData(): IContent
+    {
+        $session = \Container::$request->session();
+        $userId = $session->get('userId');
+        $challengeToken_str = \Container::$request->query('challengeToken');
+        $userInChallenge = $this->userInChallengeRepository->getByUserIdAndToken($userId, $challengeToken_str, ['challenge']);
+
+        if (!isset($userInChallenge)) {
+            return new JsonContent(['error' => 'game_not_found']);
+        }
+
+        $challenge = $userInChallenge->getChallenge();
+        $currentRound = $userInChallenge->getCurrentRound();
+
+        $response = $this->prepareChallengeResponse($userId, $challenge, $currentRound, true);
+
+        if ($challenge->getTimeLimitType() === 'game' && $challenge->getTimeLimit() !== null && $userInChallenge->getCurrentRound() > 0) {
+            $timeLimit = max(10, $userInChallenge->getTimeLeft());
+            $response['restrictions']['timeLimit'] = $timeLimit * 1000;
+        }
+
+        return new JsonContent($response);
+    }
+
+    public function guess(): IContent
+    {
+        $mapId = (int) \Container::$request->query('mapId');
+        $session = \Container::$request->session();
+
+        if (!($state = $session->get('state')) || $state['mapId'] !== $mapId) {
+            return new JsonContent(['error' => 'no_session_found']);
+        }
+
+        $last = $state['rounds'][$state['currentRound']];
+        $guessPosition = new Position((float) \Container::$request->post('lat'), (float) \Container::$request->post('lng'));
+        $result = $this->evaluateGuess($last['position'], $guessPosition, $state['area']);
+
+        $last['guessPosition'] = $guessPosition;
+        $last['distance'] = $result['distance'];
+        $last['score'] = $result['score'];
+
+        $response = [
+            'position' => $last['position']->toArray(),
+            'result' => $result
+        ];
+
+        $state['rounds'][$state['currentRound']] = $last;
+        $state['currentRound'] += 1;
+        if ($state['currentRound'] < static::NUMBER_OF_ROUNDS) {
+            $next = $state['rounds'][$state['currentRound']];
+
+            $response['place'] = [
+                'panoId' => $next['panoId'],
+                'pov' => $next['pov']->toArray()
+            ];
+        }
+
+        $session->set('state', $state);
+
+        $this->saveVisit($last['placeId']);
+
+        return new JsonContent($response);
+    }
+
+    // save the selected place for the round in UserPlayedPlace
+    private function saveVisit($placeId): void
+    {
+        $session = \Container::$request->session();
+        $userId = $session->get('userId');
+
+        if (isset($userId)) {
+            $userPlayedPlace = $this->userPlayedPlaceRepository->getByUserIdAndPlaceId($userId, $placeId);
+            if (!$userPlayedPlace) {
+                $userPlayedPlace = new UserPlayedPlace();
+                $userPlayedPlace->setUserId($userId);
+                $userPlayedPlace->setPlaceId($placeId);
+            } else {
+                $userPlayedPlace->incrementOccurrences();
+            }
+            $userPlayedPlace->setLastTimeDate(new DateTime());
+            \Container::$persistentDataManager->saveToDb($userPlayedPlace);
+        }
+    }
+
+    public function multiGuess(): IContent
+    {
+        $roomId = \Container::$request->query('roomId');
+        $session = \Container::$request->session();
+
+        if (!($multiState = $session->get('multiState')) || $multiState['roomId'] !== $roomId) {
+            return new JsonContent(['error' => 'no_session_found']);
+        }
+
+        $room = $this->multiRoomRepository->getByRoomId($roomId);
+        $state = $room->getStateArray();
+
+        $last = $state['rounds'][$state['currentRound']];
+        $guessPosition = new Position((float) \Container::$request->post('lat'), (float) \Container::$request->post('lng'));
+        $result = $this->evaluateGuess($last['position'], $guessPosition, $state['area']);
+
+        $responseFromMulti = $this->multiConnector->sendMessage('guess', [
+            'roomId' => $roomId,
+            'token' => $multiState['token'],
+            'guessPosition' => $guessPosition->toArray(),
+            'distance' => $result['distance'],
+            'score' => $result['score']
+        ]);
+
+        if (isset($responseFromMulti['error'])) {
+            return new JsonContent(['error' => $responseFromMulti['error']]);
+        }
+
+        $response = [
+            'position' => $last['position']->toArray(),
+            'result' => $result,
+            'allResults' => $responseFromMulti['allResults']
+        ];
+
+        return new JsonContent($response);
+    }
+
+    public function challengeGuess(): IContent
+    {
+        $session = \Container::$request->session();
+        $userId = $session->get('userId');
+        $challengeToken_str = \Container::$request->query('challengeToken');
+        $userInChallenge = $this->userInChallengeRepository->getByUserIdAndToken($userId, $challengeToken_str, ['challenge']);
+
+        if (!isset($userInChallenge)) {
+            return new JsonContent(['error' => 'game_not_found']);
+        }
+
+        $challenge = $userInChallenge->getChallenge();
+        $currentRound = $userInChallenge->getCurrentRound();
+        $currentPlaceInChallenge = $this->placeInChallengeRepository->getByRoundInChallenge($currentRound, $challenge, ['place', 'map']);
+        $currentPlace = $currentPlaceInChallenge->getPlace();
+        $map = $currentPlace->getMap();
+
+        // creating response
+        $nextRound = $currentRound + 1;
+        $response = $this->prepareChallengeResponse($userId, $challenge, $nextRound);
+        $response['position'] = $currentPlace->getPosition()->toArray();
+
+        if (\Container::$request->post('lat') && \Container::$request->post('lng')) {
+            $guessPosition = new Position((float) \Container::$request->post('lat'), (float) \Container::$request->post('lng'));
+            $result = $this->evaluateGuess($currentPlace->getPosition(), $guessPosition, $map->getArea());
+
+            // save guess
+            $guess = new Guess();
+            $guess->setUserId($userId);
+            $guess->setPlaceInChallenge($currentPlaceInChallenge);
+            $guess->setPosition($guessPosition);
+            $guess->setDistance($result['distance']);
+            $guess->setScore($result['score']);
+            \Container::$persistentDataManager->saveToDb($guess);
+
+            $response['result'] = $result;
+
+        } else {
+            // user didn't manage to guess in the round in the given timeframe
+            $response['result'] = ['distance' => null, 'score' => 0];
+        }
+
+        // save user relevant state of challenge
+        $userInChallenge->setCurrentRound($nextRound);
+        $timeLeft = \Container::$request->post('timeLeft');
+        if (isset($timeLeft)) {
+            $userInChallenge->setTimeLeft(intval($timeLeft));
+        }
+        \Container::$persistentDataManager->saveToDb($userInChallenge);
+
+        if ($challenge->getTimeLimitType() === 'game' && isset($timeLeft)) {
+            $timeLimit = max(10, intval($timeLeft));
+            $response['restrictions']['timeLimit'] = $timeLimit * 1000;
+        }
+
+        if (isset($response['history'][$currentRound]['allResults'])) {
+            $response['allResults'] = $response['history'][$currentRound]['allResults'];
+        }
+
+        $this->saveVisit($currentPlace->getId());
+
+        return new JsonContent($response);
+    }
+
+    public function multiNextRound(): IContent
+    {
+        $roomId = \Container::$request->query('roomId');
+        $session = \Container::$request->session();
+
+        if (!($multiState = $session->get('multiState')) || $multiState['roomId'] !== $roomId) {
+            return new JsonContent(['error' => 'no_session_found']);
+        }
+
+        $room = $this->multiRoomRepository->getByRoomId($roomId);
+        $state = $room->getStateArray();
+        $members = $room->getMembersArray();
+
+        if ($members['owner'] !== $multiState['token']) {
+            return new JsonContent(['error' => 'not_owner_of_room']);
+        }
+
+        $state['currentRound'] += 1;
+        if ($state['currentRound'] < static::NUMBER_OF_ROUNDS) {
+            $this->multiConnector->sendMessage('next_round', ['roomId' => $roomId, 'currentRound' => $state['currentRound']]);
+        }
+
+        $room->setStateArray($state);
+        $room->setUpdatedDate(new DateTime());
+        \Container::$persistentDataManager->saveToDb($room);
+
+        return new JsonContent(['ok' => true]);
+    }
+
+    private function evaluateGuess(Position $realPosition, Position $guessPosition, float $area)
+    {
+        $distance = $this->calculateDistance($realPosition, $guessPosition);
+        $score = $this->calculateScore($distance, $area);
+
+        return ['distance' => $distance, 'score' => $score];
+    }
+
+    private function startNewGame(array &$state, int $mapId): void
+    {
+        $session = \Container::$request->session();
+        $userId = $session->get('userId');
+
+        $places = $this->placeRepository->getRandomNPlaces($mapId, static::NUMBER_OF_ROUNDS, $userId);
+
+        $state['rounds'] = [];
+        $state['currentRound'] = 0;
+
+        foreach ($places as $place) {
+            $state['rounds'][] = [
+                'placeId' => $place->getId(),
+                'position' => $place->getPosition(),
+                'panoId' => $place->getPanoIdCached(),
+                'pov' => $place->getPov()
+            ];
+        }
     }
 
     private function calculateDistance(Position $realPosition, Position $guessPosition): float

src/Controller/HomeController.php

@@ -1,12 +1,21 @@
 <?php namespace MapGuesser\Controller;
 
-use MapGuesser\Interfaces\Response\IRedirect;
-use MapGuesser\Response\Redirect;
+use SokoWeb\Interfaces\Response\IContent;
+use SokoWeb\Interfaces\Response\IRedirect;
+use SokoWeb\Response\JsonContent;
+use SokoWeb\Response\Redirect;
 
 class HomeController
 {
     public function getIndex(): IRedirect
     {
-        return new Redirect([\Container::$routeCollection->getRoute('maps'), []], IRedirect::TEMPORARY);
+        return new Redirect(\Container::$routeCollection->getRoute('maps')->generateLink(), IRedirect::TEMPORARY);
+    }
+
+    public function startSession(): IContent
+    {
+        // session starts with the request, this method just sends valid data to the client
+
+        return new JsonContent(['antiCsrfToken' => \Container::$request->session()->get('anti_csrf_token')]);
     }
 }

src/Controller/LoginController.php

@@ -1,78 +1,677 @@
 <?php namespace MapGuesser\Controller;
 
-use MapGuesser\Database\Query\Select;
-use MapGuesser\Interfaces\Database\IResultSet;
-use MapGuesser\Interfaces\Request\IRequest;
-use MapGuesser\Interfaces\Response\IContent;
-use MapGuesser\Interfaces\Response\IRedirect;
-use MapGuesser\Model\User;
-use MapGuesser\Response\HtmlContent;
-use MapGuesser\Response\JsonContent;
-use MapGuesser\Response\Redirect;
+use DateInterval;
+use DateTime;
+use SokoWeb\Http\Request;
+use SokoWeb\Interfaces\Response\IContent;
+use SokoWeb\Interfaces\Response\IRedirect;
+use SokoWeb\Mailing\Mail;
+use SokoWeb\OAuth\GoogleOAuth;
+use MapGuesser\PersistentData\Model\User;
+use MapGuesser\PersistentData\Model\UserConfirmation;
+use MapGuesser\PersistentData\Model\UserPasswordResetter;
+use MapGuesser\Repository\UserConfirmationRepository;
+use MapGuesser\Repository\UserPasswordResetterRepository;
+use MapGuesser\Repository\UserPlayedPlaceRepository;
+use MapGuesser\Repository\UserRepository;
+use MapGuesser\Util\UsernameGenerator;
+use SokoWeb\Response\HtmlContent;
+use SokoWeb\Response\JsonContent;
+use SokoWeb\Response\Redirect;
+use SokoWeb\Util\CaptchaValidator;
+use SokoWeb\Util\JwtParser;
 
 class LoginController
 {
-    private IRequest $request;
+    private UserRepository $userRepository;
 
-    public function __construct(IRequest $request)
+    private UserConfirmationRepository $userConfirmationRepository;
+
+    private UserPasswordResetterRepository $userPasswordResetterRepository;
+
+    private UserPlayedPlaceRepository $userPlayedPlaceRepository;
+
+    private string $redirectUrl;
+
+    public function __construct()
     {
-        $this->request = $request;
+        $this->userRepository = new UserRepository();
+        $this->userConfirmationRepository = new UserConfirmationRepository();
+        $this->userPasswordResetterRepository = new UserPasswordResetterRepository();
+        $this->userPlayedPlaceRepository = new UserPlayedPlaceRepository();
+        $this->redirectUrl = \Container::$request->session()->has('redirect_after_login') ?
+            \Container::$request->session()->get('redirect_after_login') :
+            \Container::$routeCollection->getRoute('index')->generateLink();
     }
 
     public function getLoginForm()
     {
-        $session = $this->request->session();
-
-        if ($session->get('user')) {
-            return new Redirect([\Container::$routeCollection->getRoute('index'), []], IRedirect::TEMPORARY);
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
         }
 
-        $data = [];
-        return new HtmlContent('login', $data);
+        return new HtmlContent('login/login', ['redirectUrl' => $this->redirectUrl]);
+    }
+
+    public function getGoogleLoginRedirect(): IRedirect
+    {
+        $state = bin2hex(random_bytes(16));
+        $nonce = bin2hex(random_bytes(16));
+
+        \Container::$request->session()->set('oauth_state', $state);
+        \Container::$request->session()->set('oauth_nonce', $nonce);
+
+        $oAuth = new GoogleOAuth(new Request());
+        $url = $oAuth->getDialogUrl(
+            $state,
+            \Container::$request->getBase() . \Container::$routeCollection->getRoute('login-google-action')->generateLink(),
+            $nonce
+        );
+
+        return new Redirect($url, IRedirect::TEMPORARY);
+    }
+
+    public function getSignupForm()
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
+        }
+
+        if (\Container::$request->session()->has('tmp_user_data')) {
+            $tmpUserData = \Container::$request->session()->get('tmp_user_data');
+        } else {
+            $tmpUserData = [];
+        }
+
+        return new HtmlContent('login/signup', $tmpUserData);
+    }
+
+    public function getSignupSuccess()
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
+        }
+
+        return new HtmlContent('login/signup_success');
+    }
+
+    public function getSignupWithGoogleForm()
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
+        }
+
+        if (!\Container::$request->session()->has('google_user_data')) {
+            return new Redirect(\Container::$routeCollection->getRoute('login-google')->generateLink(), IRedirect::TEMPORARY);
+        }
+
+        $userData = \Container::$request->session()->get('google_user_data');
+
+        $user = $this->userRepository->getByEmail($userData['email']);
+
+        return new HtmlContent('login/google_signup', ['found' => $user !== null, 'email' => $userData['email'], 'redirectUrl' => $this->redirectUrl]);
+    }
+
+    public function getRequestPasswordResetForm()
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
+        }
+
+        return new HtmlContent('login/password_reset_request', ['email' => \Container::$request->query('email')]);
+    }
+
+    public function getRequestPasswordResetSuccess(): IContent
+    {
+        return new HtmlContent('login/password_reset_request_success');
+    }
+
+    public function getResetPasswordForm()
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
+        }
+
+        $token = \Container::$request->query('token');
+        $resetter = $this->userPasswordResetterRepository->getByToken($token);
+
+        if ($resetter === null || $resetter->getExpiresDate() < new DateTime()) {
+            return new HtmlContent('login/reset_password', ['success' => false]);
+        }
+
+        $user = $this->userRepository->getById($resetter->getUserId());
+
+        return new HtmlContent('login/reset_password', ['success' => true, 'token' => $token, 'email' => $user->getEmail(), 'redirectUrl' => $this->redirectUrl]);
     }
 
     public function login(): IContent
     {
-        $session = $this->request->session();
-
-        if ($session->get('user')) {
-            $data = ['success' => true];
-            return new JsonContent($data);
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new JsonContent(['success' => true]);
         }
 
-        $select = new Select(\Container::$dbConnection, 'users');
-        $select->columns(User::getFields());
-        $select->where('email', '=', $this->request->post('email'));
-
-        $userData = $select->execute()->fetch(IResultSet::FETCH_ASSOC);
-
-        if ($userData === null) {
-            $data = ['error' => 'user_not_found'];
-            return new JsonContent($data);
+        if (
+            filter_var(\Container::$request->post('email'), FILTER_VALIDATE_EMAIL) === false &&
+            preg_match('/^[a-zA-Z0-9_\-\.]+$/', \Container::$request->post('email')) !== 1
+        ) {
+            return new JsonContent(['error' => ['errorText' => 'This is not a valid email address or username.']]);
         }
 
-        $user = new User($userData);
+        $user = $this->userRepository->getByEmailOrUsername(\Container::$request->post('email'));
+
+        if ($user === null) {
+            if (strlen(\Container::$request->post('password')) < 6) {
+                return new JsonContent([
+                    'error' => [
+                        'errorText' => 'The given password is too short. Please choose a password that is at least 6 characters long!'
+                    ]
+                ]);
+            }
+
+            $tmpUser = new User();
+            $tmpUser->setPlainPassword(\Container::$request->post('password'));
+
+            $tmpUserData = ['password_hashed' => $tmpUser->getPassword()];
+            if (filter_var(\Container::$request->post('email'), FILTER_VALIDATE_EMAIL) === false) {
+                $tmpUserData['username'] = \Container::$request->post('email');
+            } else {
+                $tmpUserData['email'] = \Container::$request->post('email');
+            }
+
+            \Container::$request->session()->set('tmp_user_data', $tmpUserData);
+
+            return new JsonContent([
+                'redirect' => [
+                    'target' => \Container::$routeCollection->getRoute('signup')->generateLink()
+                ]
+            ]);
+        }
 
         if (!$user->getActive()) {
-            $data = ['error' => 'user_not_active'];
-            return new JsonContent($data);
+            $this->resendConfirmationEmail($user);
+
+            return new JsonContent([
+                'error' => [
+                    'errorText' => 'User found with the given email address / username, but the account is not activated. ' .
+                        'Please check your email and click on the activation link!'
+                ]
+            ]);
         }
 
-        if (!$user->checkPassword($this->request->post('password'))) {
-            $data = ['error' => 'password_not_match'];
-            return new JsonContent($data);
+        if (!$user->checkPassword(\Container::$request->post('password'))) {
+            return new JsonContent([
+                'error' => [
+                    'errorText' => 'The given password is wrong. You can <a href="/password/requestReset?email=' .
+                        urlencode($user->getEmail()) . '" title="Request password reset">request password reset</a>!'
+                ]
+            ]);
         }
 
-        $session->set('user', $user);
+        \Container::$request->setUser($user);
 
-        $data = ['success' => true];
-        return new JsonContent($data);
+        $this->deleteRedirectUrl();
+        return new JsonContent(['success' => true]);
+    }
+
+    public function loginWithGoogle()
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
+        }
+
+        if (\Container::$request->query('state') !== \Container::$request->session()->get('oauth_state')) {
+            return new HtmlContent('login/google_login');
+        }
+
+        $oAuth = new GoogleOAuth(new Request());
+        $tokenData = $oAuth->getToken(
+            \Container::$request->query('code'),
+            \Container::$request->getBase() . \Container::$routeCollection->getRoute('login-google-action')->generateLink()
+        );
+
+        if (!isset($tokenData['id_token'])) {
+            return new HtmlContent('login/google_login');
+        }
+
+        $jwtParser = new JwtParser($tokenData['id_token']);
+        $idToken = $jwtParser->getPayload();
+
+        if ($idToken['nonce'] !== \Container::$request->session()->get('oauth_nonce')) {
+            return new HtmlContent('login/google_login');
+        }
+
+        if (!$idToken['email_verified']) {
+            return new HtmlContent('login/google_login');
+        }
+
+        $user = $this->userRepository->getByGoogleSub($idToken['sub']);
+
+        if ($user === null) {
+            \Container::$request->session()->set('google_user_data', ['sub' => $idToken['sub'], 'email' => $idToken['email']]);
+
+            return new Redirect(\Container::$routeCollection->getRoute('signup-google')->generateLink(), IRedirect::TEMPORARY);
+        }
+
+        \Container::$request->setUser($user);
+
+        $this->deleteRedirectUrl();
+        return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
     }
 
     public function logout(): IRedirect
     {
-        $this->request->session()->delete('user');
+        \Container::$request->setUser(null);
 
-        return new Redirect([\Container::$routeCollection->getRoute('index'), []], IRedirect::TEMPORARY);
+        return new Redirect(\Container::$routeCollection->getRoute('index')->generateLink(), IRedirect::TEMPORARY);
+    }
+
+    public function signup(): IContent
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new JsonContent(['redirect' => ['target' => $this->redirectUrl]]);
+        }
+
+        $newUser = new User();
+
+        $googleUserData = \Container::$request->session()->get('google_user_data');
+        if ($googleUserData !== null) {
+            $user = $this->userRepository->getByEmail($googleUserData['email']);
+
+            if ($user !== null) {
+                return new JsonContent([
+                    'error' => [
+                        'errorText' => 'There is a user already registered with the email address of this Google account, ' .
+                            'but Google account is not linked to the user. Please <a href="/login?email=' .
+                            urlencode($googleUserData['email']) . '" title="Login">login</a> first to link your Google account!'
+                    ]
+                ]);
+            }
+
+            $newUser->setActive(true);
+            $newUser->setEmail($googleUserData['email']);
+            $newUser->setGoogleSub($googleUserData['sub']);
+        } else {
+            $user = $this->userRepository->getByEmailOrUsername(\Container::$request->post('email'));
+
+            if ($user !== null) {
+                if ($user->getActive()) {
+                    if (!$user->checkPassword(\Container::$request->post('password'))) {
+                        return new JsonContent([
+                            'error' => [
+                                'errorText' => 'There is a user already registered with the given email address / username, ' .
+                                    'but the given password is wrong. You can <a href="/password/requestReset?email=' .
+                                    urlencode($user->getEmail()) . '" title="Request password reset">request password reset</a>!'
+                            ]
+                        ]);
+                    }
+
+                    \Container::$request->setUser($user);
+
+                    $this->deleteRedirectUrl();
+                    $data = ['redirect' => ['target' => $this->redirectUrl]];
+                } else {
+                    $data = [
+                        'error' => [
+                            'errorText' => 'There is a user already registered with the given email address / username. ' .
+                                'Please check your email and click on the activation link!'
+                        ]
+                    ];
+                }
+                return new JsonContent($data);
+            }
+
+            if (!empty($_ENV['RECAPTCHA_SITEKEY'])) {
+                if (!\Container::$request->post('g-recaptcha-response')) {
+                    return new JsonContent(['error' => ['errorText' => 'Please check "I\'m not a robot" in the reCAPTCHA box!']]);
+                }
+
+                $captchaValidator = new CaptchaValidator();
+                $captchaResponse = $captchaValidator->validate(\Container::$request->post('g-recaptcha-response'));
+                if (!$captchaResponse['success']) {
+                    return new JsonContent(['error' => ['errorText' => 'reCAPTCHA challenge failed. Please try again!']]);
+                }
+            }
+
+            if (filter_var(\Container::$request->post('email'), FILTER_VALIDATE_EMAIL) === false) {
+                return new JsonContent(['error' => ['errorText' => 'The given email address is not valid.']]);
+            }
+
+            if (\Container::$request->session()->has('tmp_user_data')) {
+                $tmpUserData = \Container::$request->session()->get('tmp_user_data');
+
+                $tmpUser = new User();
+                $tmpUser->setPassword($tmpUserData['password_hashed']);
+
+                if (!$tmpUser->checkPassword(\Container::$request->post('password'))) {
+                    return new JsonContent(['error' => ['errorText' => 'The given passwords do not match.']]);
+                }
+            } else {
+                if (strlen(\Container::$request->post('password')) < 6) {
+                    return new JsonContent([
+                        'error' => [
+                            'errorText' => 'The given password is too short. Please choose a password that is at least 6 characters long!'
+                        ]
+                    ]);
+                }
+
+                if (\Container::$request->post('password') !== \Container::$request->post('password_confirm')) {
+                    return new JsonContent(['error' => ['errorText' => 'The given passwords do not match.']]);
+                }
+            }
+
+            $newUser->setActive(false);
+            $newUser->setEmail(\Container::$request->post('email'));
+            $newUser->setPlainPassword(\Container::$request->post('password'));
+        }
+
+        if (strlen(\Container::$request->post('username')) > 0) {
+            $username = \Container::$request->post('username');
+
+            if (preg_match('/^[a-zA-Z0-9_\-\.]+$/', $username) !== 1) {
+                return new JsonContent(['error' => ['errorText' => 'Username can contain only english letters, digits, - (hyphen), . (dot), _ (underscore).']]);
+            }
+
+            if ($this->userRepository->getByUsername($username) !== null) {
+                return new JsonContent(['error' => ['errorText' => 'The given username is already taken.']]);
+            }
+        } else {
+            $usernameGenerator = new UsernameGenerator();
+            do {
+                $username = $usernameGenerator->generate();
+            } while ($this->userRepository->getByUsername($username));
+        }
+
+        $newUser->setUsername($username);
+        $newUser->setCreatedDate(new DateTime());
+
+        \Container::$persistentDataManager->saveToDb($newUser);
+
+        if ($googleUserData !== null) {
+            $this->sendWelcomeEmail($newUser->getEmail());
+
+            \Container::$request->setUser($newUser);
+        } else {
+            $token = bin2hex(random_bytes(16));
+
+            $confirmation = new UserConfirmation();
+            $confirmation->setUser($newUser);
+            $confirmation->setToken($token);
+            $confirmation->setLastSentDate(new DateTime());
+
+            \Container::$persistentDataManager->saveToDb($confirmation);
+
+            $this->sendConfirmationEmail($newUser->getEmail(), $token, $newUser->getCreatedDate());
+        }
+
+        \Container::$request->session()->delete('tmp_user_data');
+        \Container::$request->session()->delete('google_user_data');
+
+        return new JsonContent(['success' => true]);
+    }
+
+    public function resetSignup(): IContent
+    {
+        \Container::$request->session()->delete('tmp_user_data');
+
+        return new JsonContent(['success' => true]);
+    }
+
+    public function resetGoogleSignup(): IContent
+    {
+        \Container::$request->session()->delete('google_user_data');
+
+        return new JsonContent(['success' => true]);
+    }
+
+    public function activate()
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
+        }
+
+        $confirmation = $this->userConfirmationRepository->getByToken(substr(\Container::$request->query('token'), 0, 32));
+
+        if ($confirmation === null) {
+            return new HtmlContent('login/activate');
+        }
+
+        \Container::$persistentDataManager->deleteFromDb($confirmation);
+
+        $user = $this->userRepository->getById($confirmation->getUserId());
+        $user->setActive(true);
+
+        \Container::$persistentDataManager->saveToDb($user);
+
+        \Container::$request->setUser($user);
+
+        $this->deleteRedirectUrl();
+        return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
+    }
+
+    public function cancel()
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new Redirect($this->redirectUrl, IRedirect::TEMPORARY);
+        }
+
+        $confirmation = $this->userConfirmationRepository->getByToken(substr(\Container::$request->query('token'), 0, 32));
+
+        if ($confirmation === null) {
+            return new HtmlContent('login/cancel', ['success' => false]);
+        }
+
+        \Container::$persistentDataManager->deleteFromDb($confirmation);
+
+        $user = $this->userRepository->getById($confirmation->getUserId());
+
+        foreach ($this->userPlayedPlaceRepository->getAllByUser($user) as $userPlayedPlace) {
+            \Container::$persistentDataManager->deleteFromDb($userPlayedPlace);
+        }
+
+        \Container::$persistentDataManager->deleteFromDb($user);
+
+        return new HtmlContent('login/cancel', ['success' => true]);
+    }
+
+    public function requestPasswordReset(): IContent
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new JsonContent([
+                'redirect' => [
+                    'target' => $this->redirectUrl
+                ]
+            ]);
+        }
+
+        if (!empty($_ENV['RECAPTCHA_SITEKEY'])) {
+            if (!\Container::$request->post('g-recaptcha-response')) {
+                return new JsonContent(['error' => ['errorText' => 'Please check "I\'m not a robot" in the reCAPTCHA box!']]);
+            }
+
+            $captchaValidator = new CaptchaValidator();
+            $captchaResponse = $captchaValidator->validate(\Container::$request->post('g-recaptcha-response'));
+            if (!$captchaResponse['success']) {
+                return new JsonContent(['error' => ['errorText' => 'reCAPTCHA challenge failed. Please try again!']]);
+            }
+        }
+
+        if (
+            filter_var(\Container::$request->post('email'), FILTER_VALIDATE_EMAIL) === false &&
+            preg_match('/^[a-zA-Z0-9_\-\.]+$/', \Container::$request->post('email')) !== 1
+        ) {
+            return new JsonContent(['error' => ['errorText' => 'This is not a valid email address or username.']]);
+        }
+
+        $user = $this->userRepository->getByEmailOrUsername(\Container::$request->post('email'));
+
+        if ($user === null) {
+            return new JsonContent([
+                'error' => [
+                    'errorText' => 'No user found with the given email address / username. You can <a href="/signup" title="Sign up">sign up</a>!'
+                ]
+            ]);
+        }
+
+        if (!$user->getActive()) {
+            $this->resendConfirmationEmail($user);
+
+            return new JsonContent([
+                'error' => [
+                    'errorText' => 'User found with the given email address / username, but the account is not activated. ' .
+                        'Please check your email and click on the activation link!'
+                ]
+            ]);
+        }
+
+        $existingResetter = $this->userPasswordResetterRepository->getByUser($user);
+
+        if ($existingResetter !== null && $existingResetter->getExpiresDate() > new DateTime()) {
+            return new JsonContent([
+                'error' => [
+                    'errorText' => 'Password reset was recently requested for this account. Please check your email, or try again later!'
+                ]
+            ]);
+        }
+
+        $token = bin2hex(random_bytes(16));
+        $expires = new DateTime('+1 hour');
+
+        $passwordResetter = new UserPasswordResetter();
+        $passwordResetter->setUser($user);
+        $passwordResetter->setToken($token);
+        $passwordResetter->setExpiresDate($expires);
+
+        if ($existingResetter !== null) {
+            \Container::$persistentDataManager->deleteFromDb($existingResetter);
+        }
+
+        \Container::$persistentDataManager->saveToDb($passwordResetter);
+
+        $this->sendPasswordResetEmail($user->getEmail(), $token, $expires);
+
+        return new JsonContent(['success' => true]);
+    }
+
+
+    public function resetPassword(): IContent
+    {
+        if (\Container::$request->user() !== null) {
+            $this->deleteRedirectUrl();
+            return new JsonContent([
+                'redirect' => [
+                    'target' => $this->redirectUrl
+                ]
+            ]);
+        }
+
+        $token = \Container::$request->query('token');
+        $resetter = $this->userPasswordResetterRepository->getByToken($token);
+
+        if ($resetter === null || $resetter->getExpiresDate() < new DateTime()) {
+            return new JsonContent([
+                'redirect' => [
+                    'target' => \Container::$routeCollection->getRoute('password-reset')->generateLink(['token' => $token])
+                ]
+            ]);
+        }
+
+        if (strlen(\Container::$request->post('password')) < 6) {
+            return new JsonContent([
+                'error' => [
+                    'errorText' => 'The given password is too short. Please choose a password that is at least 6 characters long!'
+                ]
+            ]);
+        }
+
+        if (\Container::$request->post('password') !== \Container::$request->post('password_confirm')) {
+            return new JsonContent(['error' => ['errorText' => 'The given passwords do not match.']]);
+        }
+
+        \Container::$persistentDataManager->deleteFromDb($resetter);
+
+        $user = $this->userRepository->getById($resetter->getUserId());
+        $user->setPlainPassword(\Container::$request->post('password'));
+
+        \Container::$persistentDataManager->saveToDb($user);
+
+        \Container::$request->setUser($user);
+
+        $this->deleteRedirectUrl();
+        return new JsonContent(['success' => true]);
+    }
+
+    private function sendConfirmationEmail(string $email, string $token, DateTime $created): void
+    {
+        $mail = new Mail();
+        $mail->addRecipient($email);
+        $mail->setSubject('Welcome to ' . $_ENV['APP_NAME'] . ' - Activate your account');
+        $mail->setBodyFromTemplate('signup', [
+            'EMAIL' => $email,
+            'ACTIVATE_LINK' => \Container::$request->getBase() .
+                \Container::$routeCollection->getRoute('signup.activate')->generateLink(['token' => $token]),
+            'CANCEL_LINK' => \Container::$request->getBase() .
+                \Container::$routeCollection->getRoute('signup.cancel')->generateLink(['token' => $token]),
+            'ACTIVATABLE_UNTIL' => (clone $created)->add(new DateInterval('P1D'))->format('Y-m-d H:i T')
+        ]);
+        $mail->send();
+    }
+
+    private function resendConfirmationEmail(User $user): bool
+    {
+        $confirmation = $this->userConfirmationRepository->getByUser($user);
+
+        if ($confirmation === null || (clone $confirmation->getLastSentDate())->add(new DateInterval('PT1H')) > new DateTime()) {
+            return false;
+        }
+
+        $confirmation->setLastSentDate(new DateTime());
+
+        \Container::$persistentDataManager->saveToDb($confirmation);
+
+        $this->sendConfirmationEmail($user->getEmail(), $confirmation->getToken(), $user->getCreatedDate());
+
+        return true;
+    }
+
+    private function sendWelcomeEmail(string $email): void
+    {
+        $mail = new Mail();
+        $mail->addRecipient($email);
+        $mail->setSubject('Welcome to ' . $_ENV['APP_NAME']);
+        $mail->setBodyFromTemplate('signup-noconfirm', [
+            'EMAIL' => $email,
+        ]);
+        $mail->send();
+    }
+
+    private function sendPasswordResetEmail(string $email, string $token, DateTime $expires): void
+    {
+        $mail = new Mail();
+        $mail->addRecipient($email);
+        $mail->setSubject($_ENV['APP_NAME'] . ' - Password reset');
+        $mail->setBodyFromTemplate('password-reset', [
+            'EMAIL' => $email,
+            'RESET_LINK' => \Container::$request->getBase() .
+                \Container::$routeCollection->getRoute('password-reset')->generateLink(['token' => $token]),
+            'EXPIRES' => $expires->format('Y-m-d H:i T')
+        ]);
+        $mail->send();
+    }
+
+    private function deleteRedirectUrl(): void
+    {
+        \Container::$request->session()->delete('redirect_after_login');
     }
 }

src/Controller/MapAdminController.php

@@ -1,83 +1,107 @@
 <?php namespace MapGuesser\Controller;
 
 use DateTime;
-use MapGuesser\Database\Query\Modify;
-use MapGuesser\Database\Query\Select;
-use MapGuesser\Interfaces\Authentication\IUser;
-use MapGuesser\Interfaces\Authorization\ISecured;
-use MapGuesser\Interfaces\Database\IResultSet;
-use MapGuesser\Interfaces\Request\IRequest;
-use MapGuesser\Interfaces\Response\IContent;
+use SokoWeb\Interfaces\Authentication\IUser;
+use SokoWeb\Interfaces\Authentication\IAuthenticationRequired;
+use SokoWeb\Interfaces\Authorization\ISecured;
+use SokoWeb\Interfaces\Response\IContent;
+use MapGuesser\PersistentData\Model\Challenge;
+use MapGuesser\PersistentData\Model\Map;
+use MapGuesser\PersistentData\Model\Place;
+use MapGuesser\PersistentData\Model\PlaceInChallenge;
+use MapGuesser\Repository\ChallengeRepository;
+use MapGuesser\Repository\GuessRepository;
 use MapGuesser\Repository\MapRepository;
+use MapGuesser\Repository\PlaceInChallengeRepository;
 use MapGuesser\Repository\PlaceRepository;
-use MapGuesser\Response\HtmlContent;
-use MapGuesser\Response\JsonContent;
+use MapGuesser\Repository\UserInChallengeRepository;
+use MapGuesser\Repository\UserPlayedPlaceRepository;
+use SokoWeb\Response\HtmlContent;
+use SokoWeb\Response\JsonContent;
 use MapGuesser\Util\Geo\Bounds;
-use MapGuesser\Util\Geo\Position;
+use MapGuesser\Util\Panorama\Pov;
 
-class MapAdminController implements ISecured
+class MapAdminController implements IAuthenticationRequired, ISecured
 {
     private static string $unnamedMapName = '[unnamed map]';
 
-    private IRequest $request;
-
     private MapRepository $mapRepository;
 
     private PlaceRepository $placeRepository;
 
-    public function __construct(IRequest $request)
+    private UserPlayedPlaceRepository $userPlayedPlaceRepository;
+
+    private ChallengeRepository $challengeRepository;
+
+    private GuessRepository $guessRepository;
+
+    private PlaceInChallengeRepository $placeInChallengeRepository;
+
+    private UserInChallengeRepository $userInChallengeRepository;
+
+    public function __construct()
     {
-        $this->request = $request;
         $this->mapRepository = new MapRepository();
         $this->placeRepository = new PlaceRepository();
+        $this->userPlayedPlaceRepository = new UserPlayedPlaceRepository();
+        $this->challengeRepository = new ChallengeRepository();
+        $this->guessRepository = new GuessRepository();
+        $this->placeInChallengeRepository = new PlaceInChallengeRepository();
+        $this->userInChallengeRepository = new UserInChallengeRepository();
+    }
+
+    public function isAuthenticationRequired(): bool
+    {
+        return true;
     }
 
     public function authorize(): bool
     {
-        $user = $this->request->user();
-
-        return $user !== null && $user->hasPermission(IUser::PERMISSION_ADMIN);
+        return \Container::$request->user()->hasPermission(IUser::PERMISSION_ADMIN);
     }
 
     public function getMapEditor(): IContent
     {
-        $mapId = (int) $this->request->query('mapId');
+        $mapId = (int) \Container::$request->query('mapId');
 
         if ($mapId) {
             $map = $this->mapRepository->getById($mapId);
-            $bounds = Bounds::createDirectly($map['bound_south_lat'], $map['bound_west_lng'], $map['bound_north_lat'], $map['bound_east_lng']);
-            $places = $this->getPlaces($mapId);
+            $places = $this->getPlaces($map);
         } else {
-            $map = [
-                'name' => self::$unnamedMapName,
-                'description' => ''
-            ];
-            $bounds = Bounds::createDirectly(-90.0, -180.0, 90.0, 180.0);
+            $map = new Map();
+            $map->setName(self::$unnamedMapName);
             $places = [];
         }
 
-        $data = ['mapId' => $mapId, 'mapName' => $map['name'], 'mapDescription' => str_replace('<br>', "\n", $map['description']), 'bounds' => $bounds->toArray(), 'places' => &$places];
-        return new HtmlContent('admin/map_editor', $data);
+        return new HtmlContent('admin/map_editor', [
+            'mapId' => $mapId,
+            'mapName' => $map->getName(),
+            'mapDescription' => str_replace('<br>', "\n", $map->getDescription()),
+            'mapUnlisted' => $map->getUnlisted(),
+            'bounds' => $map->getBounds()->toArray(),
+            'places' => &$places
+        ]);
     }
 
     public function getPlace(): IContent
     {
-        $placeId = (int) $this->request->query('placeId');
+        $placeId = (int) \Container::$request->query('placeId');
 
-        $placeData = $this->placeRepository->getById($placeId);
+        $place = $this->placeRepository->getById($placeId);
 
-        $data = ['panoId' => $placeData['panoId']];
-        return new JsonContent($data);
+        return new JsonContent(['panoId' => $place->getFreshPanoId()]);
     }
 
     public function saveMap(): IContent
     {
-        $mapId = (int) $this->request->query('mapId');
+        $mapId = (int) \Container::$request->query('mapId');
 
-        \Container::$dbConnection->startTransaction();
-
-        if (!$mapId) {
-            $mapId = $this->addNewMap();
+        if ($mapId) {
+            $map = $this->mapRepository->getById($mapId);
+        } else {
+            $map = new Map();
+            $map->setName(self::$unnamedMapName);
+            \Container::$persistentDataManager->saveToDb($map);
         }
 
         if (isset($_POST['added'])) {
@@ -85,11 +109,23 @@ class MapAdminController implements ISecured
             foreach ($_POST['added'] as $placeRaw) {
                 $placeRaw = json_decode($placeRaw, true);
 
-                $addedIds[] = ['tempId' => $placeRaw['id'], 'id' => $this->placeRepository->addToMap($mapId, [
-                    'lat' => (float) $placeRaw['lat'],
-                    'lng' => (float) $placeRaw['lng'],
-                    'pano_id_cached_timestamp' => $placeRaw['panoId'] === -1 ? (new DateTime('-1 day'))->format('Y-m-d H:i:s') : null
-                ])];
+                $place = new Place();
+                $place->setMap($map);
+                $place->setLat((float) $placeRaw['lat']);
+                $place->setLng((float) $placeRaw['lng']);
+                $place->setPov(new Pov(
+                    (float) $placeRaw['pov']['heading'],
+                    (float) $placeRaw['pov']['pitch'],
+                    (float) $placeRaw['pov']['zoom']
+                ));
+
+                if ($placeRaw['panoId'] === -1) {
+                    $place->setPanoIdCachedTimestampDate(new DateTime('-1 day'));
+                }
+
+                \Container::$persistentDataManager->saveToDb($place);
+
+                $addedIds[] = ['tempId' => $placeRaw['id'], 'id' => $place->getId()];
             }
         } else {
             $addedIds = [];
@@ -99,10 +135,17 @@ class MapAdminController implements ISecured
             foreach ($_POST['edited'] as $placeRaw) {
                 $placeRaw = json_decode($placeRaw, true);
 
-                $this->placeRepository->modify((int) $placeRaw['id'], [
-                    'lat' => (float) $placeRaw['lat'],
-                    'lng' => (float) $placeRaw['lng']
-                ]);
+                $place = $this->placeRepository->getById((int) $placeRaw['id']);
+                $place->setLat((float) $placeRaw['lat']);
+                $place->setLng((float) $placeRaw['lng']);
+                $place->setPov(new Pov(
+                    (float) $placeRaw['pov']['heading'],
+                    (float) $placeRaw['pov']['pitch'],
+                    (float) $placeRaw['pov']['zoom']
+                ));
+                $place->setPanoIdCachedTimestampDate(new DateTime('-1 day'));
+
+                \Container::$persistentDataManager->saveToDb($place);
             }
         }
 
@@ -110,128 +153,108 @@ class MapAdminController implements ISecured
             foreach ($_POST['deleted'] as $placeRaw) {
                 $placeRaw = json_decode($placeRaw, true);
 
-                $this->placeRepository->delete($placeRaw['id']);
+                $place = $this->placeRepository->getById((int) $placeRaw['id']);
+
+                $this->deletePlace($place);
             }
         }
 
-        $mapBounds = $this->calculateMapBounds($mapId);
+        $mapBounds = $this->calculateMapBounds($map);
 
-        $map = [
-            'bound_south_lat' => $mapBounds->getSouthLat(),
-            'bound_west_lng' => $mapBounds->getWestLng(),
-            'bound_north_lat' => $mapBounds->getNorthLat(),
-            'bound_east_lng' => $mapBounds->getEastLng(),
-            'area' => $mapBounds->calculateApproximateArea(),
-        ];
+        $map->setBounds($mapBounds);
+        $map->setArea($mapBounds->calculateApproximateArea());
 
         if (isset($_POST['name'])) {
-            $map['name'] = $_POST['name'] ? $_POST['name'] : self::$unnamedMapName;
+            $map->setName($_POST['name'] ? $_POST['name'] : self::$unnamedMapName);
         }
         if (isset($_POST['description'])) {
-            $map['description'] = str_replace(["\n", "\r\n"], '<br>', $_POST['description']);
+            $map->setDescription(str_replace(["\n", "\r\n"], '<br>', $_POST['description']));
+        }
+        if (isset($_POST['unlisted'])) {
+            $map->setUnlisted((bool)$_POST['unlisted']);
         }
 
-        $this->saveMapData($mapId, $map);
+        \Container::$persistentDataManager->saveToDb($map);
 
-        \Container::$dbConnection->commit();
-
-        $data = ['mapId' => $mapId, 'added' => $addedIds];
-        return new JsonContent($data);
+        return new JsonContent(['mapId' => $map->getId(), 'added' => $addedIds]);
     }
 
-    public function deleteMap() {
-        $mapId = (int) $this->request->query('mapId');
-
-        \Container::$dbConnection->startTransaction();
-
-        $this->deletePlaces($mapId);
-
-        $modify = new Modify(\Container::$dbConnection, 'maps');
-        $modify->setId($mapId);
-        $modify->delete();
-
-        \Container::$dbConnection->commit();
-
-        $data = ['success' => true];
-        return new JsonContent($data);
-    }
-
-    private function deletePlaces(int $mapId): void
+    public function deleteMap(): IContent
     {
-        $select = new Select(\Container::$dbConnection, 'places');
-        $select->columns(['id']);
-        $select->where('map_id', '=', $mapId);
+        $mapId = (int) \Container::$request->query('mapId');
 
-        $result = $select->execute();
+        $map = $this->mapRepository->getById($mapId);
 
-        while ($place = $result->fetch(IResultSet::FETCH_ASSOC)) {
-            $modify = new Modify(\Container::$dbConnection, 'places');
-            $modify->setId($place['id']);
-            $modify->delete();
+        $this->deletePlaces($map);
+
+        \Container::$persistentDataManager->deleteFromDb($map);
+
+        return new JsonContent(['success' => true]);
+    }
+
+    private function deletePlace(Place $place): void
+    {
+        foreach ($this->userPlayedPlaceRepository->getAllByPlace($place) as $userPlayedPlace) {
+            \Container::$persistentDataManager->deleteFromDb($userPlayedPlace);
+        }
+
+        foreach ($this->challengeRepository->getAllByPlace($place) as $challenge) {
+            $this->deleteChallenge($challenge);
+        }
+
+        \Container::$persistentDataManager->deleteFromDb($place);
+    }
+
+    private function deletePlaces(Map $map): void
+    {
+        foreach ($this->placeRepository->getAllForMap($map) as $place) {
+            $this->deletePlace($place);
         }
     }
 
-    private function calculateMapBounds(int $mapId): Bounds
+    private function deleteChallenge(Challenge $challenge): void
     {
-        $select = new Select(\Container::$dbConnection, 'places');
-        $select->columns(['lat', 'lng']);
-        $select->where('map_id', '=', $mapId);
+        foreach ($this->userInChallengeRepository->getAllByChallenge($challenge) as $userInChallenge) {
+            \Container::$persistentDataManager->deleteFromDb($userInChallenge);
+        }
 
-        $result = $select->execute();
+        foreach ($this->guessRepository->getAllInChallenge($challenge, ['place_in_challange']) as $guess) {
+            \Container::$persistentDataManager->deleteFromDb($guess);
+        }
 
+        foreach ($this->placeInChallengeRepository->getAllByChallenge($challenge) as $placeInChallenge) {
+            \Container::$persistentDataManager->deleteFromDb($placeInChallenge);
+        }
+
+        \Container::$persistentDataManager->deleteFromDb($challenge);
+    }
+
+    private function calculateMapBounds(Map $map): Bounds
+    {
         $bounds = new Bounds();
-        while ($place = $result->fetch(IResultSet::FETCH_ASSOC)) {
-            $bounds->extend(new Position($place['lat'], $place['lng']));
+
+        foreach ($this->placeRepository->getAllForMap($map) as $place) {
+            $bounds->extend($place->getPosition());
         }
 
         return $bounds;
     }
 
-    private function addNewMap(): int
+    private function &getPlaces(Map $map): array
     {
-        $modify = new Modify(\Container::$dbConnection, 'maps');
-        $modify->fill([
-            'name' => self::$unnamedMapName,
-            'description' => '',
-            'bound_south_lat' => 0.0,
-            'bound_west_lng' => 0.0,
-            'bound_north_lat' => 0.0,
-            'bound_east_lng' => 0.0
-        ]);
-        $modify->save();
-
-        return $modify->getId();
-    }
-
-    private function saveMapData(int $mapId, array $map): void
-    {
-        $modify = new Modify(\Container::$dbConnection, 'maps');
-        $modify->setId($mapId);
-        $modify->fill($map);
-        $modify->save();
-    }
-
-    private function &getPlaces(int $mapId): array
-    {
-        $select = new Select(\Container::$dbConnection, 'places');
-        $select->columns(['id', 'lat', 'lng', 'pano_id_cached', 'pano_id_cached_timestamp']);
-        $select->where('map_id', '=', $mapId);
-
-        $result = $select->execute();
-
         $places = [];
 
-        while ($place = $result->fetch(IResultSet::FETCH_ASSOC)) {
-            //$panoId = ???
-            //$pov = ???
-            $noPano = $place['pano_id_cached_timestamp'] && $place['pano_id_cached'] === null;
+        foreach ($this->placeRepository->getAllForMap($map) as $place) {
+            $noPano = $place->getPanoIdCachedTimestampDate() !== null && $place->getPanoIdCached() === null;
 
-            $places[$place['id']] = [
-                'id' => $place['id'],
-                'lat' => $place['lat'],
-                'lng' => $place['lng'],
+            $placeId = $place->getId();
+
+            $places[$placeId] = [
+                'id' => $placeId,
+                'lat' => $place->getLat(),
+                'lng' => $place->getLng(),
                 'panoId' => null,
-                'pov' => ['heading' => 0.0, 'pitch' => 0.0, 'zoom' => 0.0],
+                'pov' => $place->getPov()->toArray(),
                 'noPano' => $noPano
             ];
         }

src/Controller/MapsController.php

@@ -1,24 +1,17 @@
 <?php namespace MapGuesser\Controller;
 
-use MapGuesser\Database\Query\Select;
-use MapGuesser\Database\RawExpression;
-use MapGuesser\Interfaces\Authentication\IUser;
-use MapGuesser\Interfaces\Database\IResultSet;
-use MapGuesser\Interfaces\Request\IRequest;
-use MapGuesser\Interfaces\Response\IContent;
-use MapGuesser\Response\HtmlContent;
+use SokoWeb\Database\Query\Select;
+use SokoWeb\Database\RawExpression;
+use SokoWeb\Interfaces\Authentication\IUser;
+use SokoWeb\Interfaces\Database\IResultSet;
+use SokoWeb\Interfaces\Response\IContent;
+use SokoWeb\Response\HtmlContent;
 
 class MapsController
 {
-    private IRequest $request;
-
-    public function __construct(IRequest $request)
-    {
-        $this->request = $request;
-    }
-
     public function getMaps(): IContent
     {
+        //TODO: from repository - count should be added
         $select = new Select(\Container::$dbConnection, 'maps');
         $select->columns([
             ['maps', 'id'],
@@ -29,12 +22,19 @@ class MapsController
             ['maps', 'bound_north_lat'],
             ['maps', 'bound_east_lng'],
             ['maps', 'area'],
+            ['maps', 'unlisted'],
             new RawExpression('COUNT(places.id) AS num_places')
         ]);
         $select->leftJoin('places', ['places', 'map_id'], '=', ['maps', 'id']);
         $select->groupBy(['maps', 'id']);
         $select->orderBy('name');
 
+        $user = \Container::$request->user();
+        $isAdmin = $user !== null && $user->hasPermission(IUser::PERMISSION_ADMIN);
+        if (!$isAdmin) {
+            $select->where(['maps', 'unlisted'], '=', false);
+        }
+
         $result = $select->execute();
 
         $maps = [];
@@ -44,9 +44,11 @@ class MapsController
             $maps[] = $map;
         }
 
-        $user = $this->request->user();
-        $data = ['maps' => $maps, 'isAdmin' => $user !== null && $user->hasPermission(IUser::PERMISSION_ADMIN)];
-        return new HtmlContent('maps', $data);
+        return new HtmlContent('maps', [
+            'maps' => $maps,
+            'isLoggedIn' => $user !== null,
+            'isAdmin' => $isAdmin
+        ]);
     }
 
     private function formatMapAreaForHuman(float $area): array

src/Controller/SignupController.php

@@ -1,192 +0,0 @@
-<?php namespace MapGuesser\Controller;
-
-use MapGuesser\Database\Query\Modify;
-use MapGuesser\Database\Query\Select;
-use MapGuesser\Interfaces\Database\IResultSet;
-use MapGuesser\Interfaces\Request\IRequest;
-use MapGuesser\Interfaces\Response\IContent;
-use MapGuesser\Interfaces\Response\IRedirect;
-use MapGuesser\Mailing\Mail;
-use MapGuesser\Model\User;
-use MapGuesser\Response\HtmlContent;
-use MapGuesser\Response\JsonContent;
-use MapGuesser\Response\Redirect;
-
-class SignupController
-{
-    private IRequest $request;
-
-    public function __construct(IRequest $request)
-    {
-        $this->request = $request;
-    }
-
-    public function getSignupForm()
-    {
-        $session = $this->request->session();
-
-        if ($session->get('user')) {
-            return new Redirect([\Container::$routeCollection->getRoute('index'), []], IRedirect::TEMPORARY);
-        }
-
-        $data = [];
-        return new HtmlContent('signup/signup', $data);
-    }
-
-    public function signup(): IContent
-    {
-        $session = $this->request->session();
-
-        if ($session->get('user')) {
-            //TODO: return with some error
-            $data = ['success' => true];
-            return new JsonContent($data);
-        }
-
-        $select = new Select(\Container::$dbConnection, 'users');
-        $select->columns(User::getFields());
-        $select->where('email', '=', $this->request->post('email'));
-
-        $userData = $select->execute()->fetch(IResultSet::FETCH_ASSOC);
-
-        if ($userData !== null) {
-            $user = new User($userData);
-
-            if ($user->getActive()) {
-                $data = ['error' => 'user_found'];
-            } else {
-                $data = ['error' => 'not_active_user_found'];
-            }
-            return new JsonContent($data);
-        }
-
-        if (strlen($this->request->post('password')) < 6) {
-            $data = ['error' => 'passwords_too_short'];
-            return new JsonContent($data);
-        }
-
-        if ($this->request->post('password') !== $this->request->post('password_confirm')) {
-            $data = ['error' => 'passwords_not_match'];
-            return new JsonContent($data);
-        }
-
-        $user = new User([
-            'email' => $this->request->post('email'),
-        ]);
-
-        $user->setPlainPassword($this->request->post('password'));
-
-        \Container::$dbConnection->startTransaction();
-
-        $modify = new Modify(\Container::$dbConnection, 'users');
-        $modify->fill($user->toArray());
-        $modify->save();
-        $userId = $modify->getId();
-
-        $token = hash('sha256', serialize($user) . random_bytes(10) . microtime());
-
-        $modify = new Modify(\Container::$dbConnection, 'user_confirmations');
-        $modify->set('user_id', $userId);
-        $modify->set('token', $token);
-        $modify->save();
-
-        \Container::$dbConnection->commit();
-
-        $this->sendConfirmationEmail($user->getEmail(), $token);
-
-        $data = ['success' => true];
-        return new JsonContent($data);
-    }
-
-    public function activate()
-    {
-        $session = $this->request->session();
-
-        if ($session->get('user')) {
-            return new Redirect([\Container::$routeCollection->getRoute('index'), []], IRedirect::TEMPORARY);
-        }
-
-        $select = new Select(\Container::$dbConnection, 'user_confirmations');
-        $select->columns(['id', 'user_id']);
-        $select->where('token', '=', $this->request->query('token'));
-
-        $confirmation = $select->execute()->fetch(IResultSet::FETCH_ASSOC);
-
-        if ($confirmation === null) {
-            $data = [];
-            return new HtmlContent('signup/activate', $data);
-        }
-
-        \Container::$dbConnection->startTransaction();
-
-        $modify = new Modify(\Container::$dbConnection, 'user_confirmations');
-        $modify->setId($confirmation['id']);
-        $modify->delete();
-
-        $modify = new Modify(\Container::$dbConnection, 'users');
-        $modify->setId($confirmation['user_id']);
-        $modify->set('active', true);
-        $modify->save();
-
-        \Container::$dbConnection->commit();
-
-        $select = new Select(\Container::$dbConnection, 'users');
-        $select->columns(User::getFields());
-        $select->whereId($confirmation['user_id']);
-
-        $userData = $select->execute()->fetch(IResultSet::FETCH_ASSOC);
-        $user = new User($userData);
-
-        $session->set('user', $user);
-
-        return new Redirect([\Container::$routeCollection->getRoute('index'), []], IRedirect::TEMPORARY);
-    }
-
-    public function cancel()
-    {
-        $session = $this->request->session();
-
-        if ($session->get('user')) {
-            return new Redirect([\Container::$routeCollection->getRoute('index'), []], IRedirect::TEMPORARY);
-        }
-
-        $select = new Select(\Container::$dbConnection, 'user_confirmations');
-        $select->columns(['id', 'user_id']);
-        $select->where('token', '=', $this->request->query('token'));
-
-        $confirmation = $select->execute()->fetch(IResultSet::FETCH_ASSOC);
-
-        if ($confirmation === null) {
-            $data = ['success' => false];
-            return new HtmlContent('signup/cancel', $data);
-        }
-
-        \Container::$dbConnection->startTransaction();
-
-        $modify = new Modify(\Container::$dbConnection, 'user_confirmations');
-        $modify->setId($confirmation['id']);
-        $modify->delete();
-
-        $modify = new Modify(\Container::$dbConnection, 'users');
-        $modify->setId($confirmation['user_id']);
-        $modify->delete();
-
-        \Container::$dbConnection->commit();
-
-        $data = ['success' => true];
-        return new HtmlContent('signup/cancel', $data);
-    }
-
-    private function sendConfirmationEmail($email, $token): void
-    {
-        $mail = new Mail();
-        $mail->addRecipient($email);
-        $mail->setSubject('Welcome to MapGuesser - Activate your account');
-        $mail->setBodyFromTemplate('signup', [
-            'EMAIL' => $email,
-            'ACTIVATE_LINK' => $this->request->getBase() . '/signup/activate/' . $token,
-            'CANCEL_LINK' => $this->request->getBase() . '/signup/cancel/' . $token,
-        ]);
-        $mail->send();
-    }
-}

src/Controller/UserController.php

@@ -1,64 +1,399 @@
 <?php namespace MapGuesser\Controller;
 
-use MapGuesser\Database\Query\Modify;
-use MapGuesser\Interfaces\Authorization\ISecured;
-use MapGuesser\Interfaces\Request\IRequest;
-use MapGuesser\Interfaces\Response\IContent;
-use MapGuesser\Response\HtmlContent;
-use MapGuesser\Response\JsonContent;
+use DateTime;
+use SokoWeb\Http\Request;
+use SokoWeb\Interfaces\Authentication\IAuthenticationRequired;
+use SokoWeb\Interfaces\Response\IContent;
+use SokoWeb\Interfaces\Response\IRedirect;
+use SokoWeb\OAuth\GoogleOAuth;
+use MapGuesser\PersistentData\Model\User;
+use MapGuesser\Repository\GuessRepository;
+use MapGuesser\Repository\UserRepository;
+use MapGuesser\Repository\UserConfirmationRepository;
+use MapGuesser\Repository\UserInChallengeRepository;
+use MapGuesser\Repository\UserPasswordResetterRepository;
+use MapGuesser\Repository\UserPlayedPlaceRepository;
+use SokoWeb\Response\HtmlContent;
+use SokoWeb\Response\JsonContent;
+use SokoWeb\Response\Redirect;
+use SokoWeb\Util\JwtParser;
 
-class UserController implements ISecured
+class UserController implements IAuthenticationRequired
 {
-    private IRequest $request;
+    private UserRepository $userRepository;
 
-    public function __construct(IRequest $request)
+    private UserConfirmationRepository $userConfirmationRepository;
+
+    private UserPasswordResetterRepository $userPasswordResetterRepository;
+
+    private UserPlayedPlaceRepository $userPlayedPlaceRepository;
+
+    private UserInChallengeRepository $userInChallengeRepository;
+
+    private GuessRepository $guessRepository;
+
+    public function __construct()
     {
-        $this->request = $request;
+        $this->userRepository = new UserRepository();
+        $this->userConfirmationRepository = new UserConfirmationRepository();
+        $this->userPasswordResetterRepository = new UserPasswordResetterRepository();
+        $this->userPlayedPlaceRepository = new UserPlayedPlaceRepository();
+        $this->userInChallengeRepository = new UserInChallengeRepository();
+        $this->guessRepository = new GuessRepository();
     }
 
-    public function authorize(): bool
+    public function isAuthenticationRequired(): bool
     {
-        $user = $this->request->user();
-
-        return $user !== null;
+        return true;
     }
 
-    public function getProfile(): IContent
+    public function getAccount(): IContent
     {
-        $user = $this->request->user();
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
 
-        $data = ['user' => $user->toArray()];
-        return new HtmlContent('profile', $data);
+        return new HtmlContent('account/account', ['user' => $user->toArray()]);
     }
 
-    public function saveProfile(): IContent
+    public function getGoogleConnectRedirect(): IRedirect
     {
-        $user = $this->request->user();
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
 
-        if (!$user->checkPassword($this->request->post('password'))) {
-            $data = ['error' => 'password_not_match'];
-            return new JsonContent($data);
+        $state = bin2hex(random_bytes(16));
+        $nonce = bin2hex(random_bytes(16));
+
+        \Container::$request->session()->set('oauth_state', $state);
+        \Container::$request->session()->set('oauth_nonce', $nonce);
+
+        $oAuth = new GoogleOAuth(new Request());
+
+        $url = $oAuth->getDialogUrl(
+            $state,
+            \Container::$request->getBase() . \Container::$routeCollection->getRoute('account.googleConnect-confirm')->generateLink(),
+            $nonce,
+            $user->getEmail()
+        );
+
+        return new Redirect($url, IRedirect::TEMPORARY);
+    }
+
+    public function getGoogleConnectConfirm(): IContent
+    {
+        $defaultError = 'Authentication with Google failed. Please <a href="' . \Container::$routeCollection->getRoute('account.googleConnect')->generateLink() . '" title="Connect with Google">try again</a>!';
+
+        if (\Container::$request->query('state') !== \Container::$request->session()->get('oauth_state')) {
+            return new HtmlContent('account/google_connect', ['success' => false, 'error' => $defaultError]);
         }
 
-        if (strlen($this->request->post('password_new')) > 0) {
-            if (strlen($this->request->post('password_new')) < 6) {
-                $data = ['error' => 'passwords_too_short'];
-                return new JsonContent($data);
-            }
-
-            if ($this->request->post('password_new') !== $this->request->post('password_new_confirm')) {
-                $data = ['error' => 'passwords_not_match'];
-                return new JsonContent($data);
-            }
-
-            $user->setPlainPassword($this->request->post('password_new'));
+        $oAuth = new GoogleOAuth(new Request());
+        $tokenData = $oAuth->getToken(
+            \Container::$request->query('code'),
+            \Container::$request->getBase() . \Container::$routeCollection->getRoute('account.googleConnect-confirm')->generateLink()
+        );
+        if (!isset($tokenData['id_token'])) {
+            return new HtmlContent('account/google_connect', ['success' => false, 'error' => $defaultError]);
         }
 
-        $modify = new Modify(\Container::$dbConnection, 'users');
-        $modify->fill($user->toArray());
-        $modify->save();
+        $jwtParser = new JwtParser($tokenData['id_token']);
+        $idToken = $jwtParser->getPayload();
+        if ($idToken['nonce'] !== \Container::$request->session()->get('oauth_nonce')) {
+            return new HtmlContent('account/google_connect', ['success' => false, 'error' => $defaultError]);
+        }
 
-        $data = ['success' => true];
-        return new JsonContent($data);
+        $anotherUser = $this->userRepository->getByGoogleSub($idToken['sub']);
+        if ($anotherUser !== null) {
+            return new HtmlContent('account/google_connect', [
+                'success' => false,
+                'error' => 'This Google account is linked to another account.'
+            ]);
+        }
+
+        \Container::$request->session()->set('google_user_data', $idToken);
+
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
+
+        return new HtmlContent('account/google_connect', [
+            'success' => true,
+            'googleAccount' => $idToken['email'],
+            'userEmail' => $user->getEmail()
+        ]);
+    }
+
+    public function connectGoogle(): IContent
+    {
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
+        if (!$user->checkPassword(\Container::$request->post('password'))) {
+            return new JsonContent([
+                'error' => [
+                    'errorText' => 'The given password is wrong.'
+                ]
+            ]);
+        }
+
+        $googleUserData = \Container::$request->session()->get('google_user_data');
+        $user->setGoogleSub($googleUserData['sub']);
+        \Container::$persistentDataManager->saveToDb($user);
+
+        return new JsonContent(['success' => true]);
+    }
+
+    public function getGoogleDisconnectConfirm(): IContent
+    {
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
+
+        return new HtmlContent('account/google_disconnect', [
+            'success' => true,
+            'userEmail' => $user->getEmail()
+        ]);
+    }
+
+    public function disconnectGoogle(): IContent
+    {
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
+        if (!$user->checkPassword(\Container::$request->post('password'))) {
+            return new JsonContent([
+                'error' => [
+                    'errorText' => 'The given password is wrong.'
+                ]
+            ]);
+        }
+
+        $user->setGoogleSub(null);
+        \Container::$persistentDataManager->saveToDb($user);
+
+        return new JsonContent(['success' => true]);
+    }
+
+    public function getGoogleAuthenticateRedirect(): IRedirect
+    {
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
+
+        $state = bin2hex(random_bytes(16));
+        $nonce = bin2hex(random_bytes(16));
+
+        \Container::$request->session()->set('oauth_state', $state);
+        \Container::$request->session()->set('oauth_nonce', $nonce);
+
+        $oAuth = new GoogleOAuth(new Request());
+
+        $url = $oAuth->getDialogUrl(
+            $state,
+            \Container::$request->getBase() . \Container::$routeCollection->getRoute('account.googleAuthenticate-action')->generateLink(),
+            $nonce,
+            $user->getEmail()
+        );
+
+        return new Redirect($url, IRedirect::TEMPORARY);
+    }
+
+    public function authenticateWithGoogle(): IContent
+    {
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
+
+        if (\Container::$request->query('state') !== \Container::$request->session()->get('oauth_state')) {
+            return new HtmlContent('account/google_authenticate', ['success' => false]);
+        }
+
+        $oAuth = new GoogleOAuth(new Request());
+        $tokenData = $oAuth->getToken(
+            \Container::$request->query('code'),
+            \Container::$request->getBase() . \Container::$routeCollection->getRoute('account.googleAuthenticate-action')->generateLink()
+        );
+
+        if (!isset($tokenData['id_token'])) {
+            return new HtmlContent('account/google_authenticate', ['success' => false]);
+        }
+
+        $jwtParser = new JwtParser($tokenData['id_token']);
+        $idToken = $jwtParser->getPayload();
+
+        if ($idToken['nonce'] !== \Container::$request->session()->get('oauth_nonce')) {
+            return new HtmlContent('account/google_authenticate', ['success' => false]);
+        }
+
+        if ($idToken['sub'] !== $user->getGoogleSub()) {
+            return new HtmlContent('account/google_authenticate', [
+                'success' => false,
+                'errorText' => 'This Google account is not linked to your account.'
+            ]);
+        }
+
+        $authenticatedWithGoogleUntil = new DateTime('+45 seconds');
+        \Container::$request->session()->set('authenticated_with_google_until', $authenticatedWithGoogleUntil);
+
+        return new HtmlContent('account/google_authenticate', [
+            'success' => true,
+            'authenticatedWithGoogleUntil' => $authenticatedWithGoogleUntil
+        ]);
+    }
+
+    public function getDeleteAccount(): IContent
+    {
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
+
+        return new HtmlContent('account/delete', ['user' => $user->toArray()]);
+    }
+
+    public function saveAccount(): IContent
+    {
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
+
+        if (!$this->confirmUserIdentity(
+            $user,
+            \Container::$request->session()->get('authenticated_with_google_until'),
+            \Container::$request->post('password'),
+            $error
+        )) {
+            return new JsonContent(['error' => ['errorText' => $error]]);
+        }
+
+        $newEmail = \Container::$request->post('email');
+        if ($newEmail !== $user->getEmail()) {
+            if (!filter_var($newEmail, FILTER_VALIDATE_EMAIL)) {
+                return new JsonContent(['error' => ['errorText' => 'The given email address is not valid.']]);
+            }
+
+            if ($this->userRepository->getByEmail($newEmail) !== null) {
+                return new JsonContent(['error' => ['errorText' => 'The given email address belongs to another account.']]);
+            }
+
+            $user->setEmail($newEmail);
+        }
+
+        $newUsername = \Container::$request->post('username');
+        if ($newUsername !== $user->getUsername()) {
+            if (strlen($newUsername) == 0) {
+                return new JsonContent(['error' => ['errorText' => 'Username cannot be empty.']]);
+            }
+
+            if (preg_match('/^[a-zA-Z0-9_\-\.]+$/', $newUsername) !== 1) {
+                return new JsonContent(['error' => ['errorText' => 'Username can contain only english letters, digits, - (hyphen), . (dot), _ (underscore).']]);
+            }
+
+            if ($this->userRepository->getByUsername($newUsername) !== null) {
+                return new JsonContent(['error' => ['errorText' => 'The given username is already taken.']]);
+            }
+
+            $user->setUsername($newUsername);
+        }
+
+        if (strlen(\Container::$request->post('password_new')) > 0) {
+            if (strlen(\Container::$request->post('password_new')) < 6) {
+                return new JsonContent([
+                    'error' => [
+                        'errorText' => 'The given new password is too short. Please choose a password that is at least 6 characters long!'
+                    ]
+                ]);
+            }
+
+            if (\Container::$request->post('password_new') !== \Container::$request->post('password_new_confirm')) {
+                return new JsonContent([
+                    'error' => [
+                        'errorText' => 'The given new passwords do not match.'
+                    ]
+                ]);
+            }
+
+            $user->setPlainPassword(\Container::$request->post('password_new'));
+        }
+
+        \Container::$persistentDataManager->saveToDb($user);
+
+        \Container::$request->session()->delete('authenticated_with_google_until');
+
+        return new JsonContent(['success' => true]);
+    }
+
+    public function deleteAccount(): IContent
+    {
+        /**
+         * @var User $user
+         */
+        $user = \Container::$request->user();
+
+        if (!$this->confirmUserIdentity(
+            $user,
+            \Container::$request->session()->get('authenticated_with_google_until'),
+            \Container::$request->post('password'),
+            $error
+        )) {
+            return new JsonContent(['error' => ['errorText' => $error]]);
+        }
+
+        $userConfirmation = $this->userConfirmationRepository->getByUser($user);
+        if ($userConfirmation !== null) {
+            \Container::$persistentDataManager->deleteFromDb($userConfirmation);
+        }
+
+        $userPasswordResetter = $this->userPasswordResetterRepository->getByUser($user);
+        if ($userPasswordResetter !== null) {
+            \Container::$persistentDataManager->deleteFromDb($userPasswordResetter);
+        }
+
+        foreach ($this->userPlayedPlaceRepository->getAllByUser($user) as $userPlayedPlace) {
+            \Container::$persistentDataManager->deleteFromDb($userPlayedPlace);
+        }
+
+        foreach ($this->userInChallengeRepository->getAllByUser($user) as $userInChallenge) {
+            \Container::$persistentDataManager->deleteFromDb($userInChallenge);
+        }
+
+        foreach ($this->guessRepository->getAllByUser($user) as $guess) {
+            \Container::$persistentDataManager->deleteFromDb($guess);
+        }
+
+        \Container::$persistentDataManager->deleteFromDb($user);
+
+        \Container::$request->session()->delete('authenticated_with_google_until');
+
+        return new JsonContent(['success' => true]);
+    }
+
+    private function confirmUserIdentity(User $user, ?DateTime $authenticatedWithGoogleUntil, ?string $password, ?string &$error): bool
+    {
+        if ($authenticatedWithGoogleUntil !== null && $authenticatedWithGoogleUntil > new DateTime()) {
+            return true;
+        }
+
+        if ($password !== null) {
+            if ($user->checkPassword($password)) {
+                return true;
+            }
+
+            $error = 'The given current password is wrong.';
+            return false;
+        }
+
+        $error = 'Could not confirm your identity. Please try again!';
+        return false;
     }
 }

src/Database/Mysql/Connection.php

@@ -1,114 +0,0 @@
-<?php namespace MapGuesser\Database\Mysql;
-
-use MapGuesser\Interfaces\Database\IConnection;
-use MapGuesser\Interfaces\Database\IResultSet;
-use MapGuesser\Interfaces\Database\IStatement;
-use mysqli;
-
-class Connection implements IConnection
-{
-    private mysqli $connection;
-
-    public function __construct(string $host, string $user, string $password, string $db, int $port = -1, string $socket = null)
-    {
-        if ($port < 0) {
-            $port = ini_get('mysqli.default_port');
-        }
-
-        if ($socket === null) {
-            $socket = ini_get('mysqli.default_socket');
-        }
-
-        $this->connection = new mysqli($host, $user, $password, $db, $port, $socket);
-
-        if ($this->connection->connect_error) {
-            throw new \Exception('Connection failed: ' . $this->connection->connect_error);
-        }
-
-        if (!$this->connection->set_charset('utf8mb4')) {
-            throw new \Exception($this->connection->error);
-        }
-    }
-
-    public function __destruct()
-    {
-        $this->connection->close();
-    }
-
-    public function startTransaction(): void
-    {
-        if (!$this->connection->autocommit(false)) {
-            throw new \Exception($this->connection->error);
-        }
-    }
-
-    public function commit(): void
-    {
-        if (!$this->connection->commit() || !$this->connection->autocommit(true)) {
-            throw new \Exception($this->connection->error);
-        }
-    }
-
-    public function rollback(): void
-    {
-        if (!$this->connection->rollback() || !$this->connection->autocommit(true)) {
-            throw new \Exception($this->connection->error);
-        }
-    }
-
-    public function query(string $query): ?IResultSet
-    {
-        if (!($result = $this->connection->query($query))) {
-            throw new \Exception($this->connection->error . '. Query: ' . $query);
-        }
-
-        if ($result !== true) {
-            return new ResultSet($result);
-        }
-
-        return null;
-    }
-
-    public function multiQuery(string $query): array
-    {
-        if (!$this->connection->multi_query($query)) {
-            throw new \Exception($this->connection->error . '. Query: ' . $query);
-        }
-
-        $ret = [];
-        do {
-            if ($result = $this->connection->store_result()) {
-                $ret[] = new ResultSet($result);
-            } else {
-                $ret[] = null;
-            }
-
-            $this->connection->more_results();
-        } while ($this->connection->next_result());
-
-        if ($this->connection->error) {
-            throw new \Exception($this->connection->error  . '. Query: ' . $query);
-        }
-
-        return $ret;
-    }
-
-    public function prepare(string $query): IStatement
-    {
-        if (!($stmt = $this->connection->prepare($query))) {
-            throw new \Exception($this->connection->error . '. Query: ' . $query);
-        }
-
-        return new Statement($stmt);
-    }
-
-    public function lastId(): int
-    {
-        return $this->connection->insert_id;
-    }
-
-    public function getAffectedRows(): int
-    {
-        return $this->connection->affected_rows;
-    }
-}

src/Database/Mysql/ResultSet.php

@@ -1,62 +0,0 @@
-<?php namespace MapGuesser\Database\Mysql;
-
-use MapGuesser\Interfaces\Database\IResultSet;
-use mysqli_result;
-
-class ResultSet implements IResultSet
-{
-    private mysqli_result $result;
-
-    public function __construct(mysqli_result $result)
-    {
-        $this->result = $result;
-    }
-
-    public function fetch(int $type = IResultSet::FETCH_ASSOC): ?array
-    {
-        return $this->result->fetch_array($this->convertFetchType($type));
-    }
-
-    public function fetchAll(int $type = IResultSet::FETCH_ASSOC): array
-    {
-        return $this->result->fetch_all($this->convertFetchType($type));
-    }
-
-    public function fetchOneColumn(string $valueName, string $keyName = null): array
-    {
-        $array = [];
-
-        while ($r = $this->fetch(IResultSet::FETCH_ASSOC)) {
-            if (isset($keyName)) {
-                $array[$r[$keyName]] = $r[$valueName];
-            } else {
-                $array[] = $r[$valueName];
-            }
-        }
-
-        return $array;
-    }
-
-    private function convertFetchType(int $type): int
-    {
-        switch ($type) {
-            case IResultSet::FETCH_ASSOC:
-                $internal_type = MYSQLI_ASSOC;
-                break;
-
-            case IResultSet::FETCH_BOTH:
-                $internal_type = MYSQLI_BOTH;
-                break;
-
-            case IResultSet::FETCH_NUM:
-                $internal_type = MYSQLI_NUM;
-                break;
-
-            default:
-                $internal_type = MYSQLI_BOTH;
-                break;
-        }
-
-        return $internal_type;
-    }
-}

src/Database/Mysql/Statement.php

@@ -1,79 +0,0 @@
-<?php namespace MapGuesser\Database\Mysql;
-
-use MapGuesser\Interfaces\Database\IResultSet;
-use MapGuesser\Interfaces\Database\IStatement;
-use mysqli_stmt;
-
-class Statement implements IStatement
-{
-    private mysqli_stmt $stmt;
-
-    public function __construct(mysqli_stmt $stmt)
-    {
-        $this->stmt = $stmt;
-    }
-
-    public function __destruct()
-    {
-        $this->stmt->close();
-    }
-
-    public function execute(array $params = []): ?IResultSet
-    {
-        if ($params) {
-            $ref_params = [''];
-
-            foreach ($params as &$param) {
-                $type = gettype($param);
-
-                switch ($type) {
-                    case 'integer':
-                    case 'double':
-                    case 'string':
-                        $t = $type[0];
-                        break;
-
-                    case 'NULL':
-                        $t = 's';
-                        break;
-
-                    case 'boolean':
-                        $param = (string) (int) $param;
-                        $t = 's';
-                        break;
-
-                    case 'array':
-                        $param = json_encode($param);
-                        $t = 's';
-                        break;
-                }
-
-                if (!isset($t)) {
-                    throw new \Exception('Data type ' . $type . ' not supported!');
-                }
-
-                $ref_params[] = &$param;
-                $ref_params[0] .= $t;
-            }
-
-            if (!call_user_func_array([$this->stmt, 'bind_param'], $ref_params)) {
-                throw new \Exception($this->stmt->error);
-            }
-        }
-
-        if (!$this->stmt->execute()) {
-            throw new \Exception($this->stmt->error);
-        }
-
-        if ($result_set = $this->stmt->get_result()) {
-            return new ResultSet($result_set);
-        }
-
-        return null;
-    }
-
-    public function getAffectedRows(): int
-    {
-        return $this->stmt->affected_rows;
-    }
-}

src/Database/Query/Modify.php

@@ -1,176 +0,0 @@
-<?php namespace MapGuesser\Database\Query;
-
-use MapGuesser\Interfaces\Database\IConnection;
-use MapGuesser\Interfaces\Database\IResultSet;
-use MapGuesser\Database\Utils;
-
-class Modify
-{
-    private IConnection $connection;
-
-    private string $table;
-
-    private string $idName = 'id';
-
-    private array $attributes = [];
-
-    private array $original = [];
-
-    private ?string $externalId = null;
-
-    private bool $autoIncrement = true;
-
-    public function __construct(IConnection $connection, string $table)
-    {
-        $this->connection = $connection;
-        $this->table = $table;
-    }
-
-    public function setIdName(string $idName): Modify
-    {
-        $this->idName = $idName;
-
-        return $this;
-    }
-
-    public function setExternalId($id): Modify
-    {
-        $this->externalId = $id;
-
-        return $this;
-    }
-
-    public function setAutoIncrement(bool $autoIncrement = true): Modify
-    {
-        $this->autoIncrement = $autoIncrement;
-
-        return $this;
-    }
-
-    public function fill(array $attributes): Modify
-    {
-        $this->attributes = array_merge($this->attributes, $attributes);
-
-        return $this;
-    }
-
-    public function set(string $name, $value): Modify
-    {
-        $this->attributes[$name] = $value;
-
-        return $this;
-    }
-
-    public function setId($id): Modify
-    {
-        $this->attributes[$this->idName] = $id;
-
-        return $this;
-    }
-
-    public function getId()
-    {
-        return $this->attributes[$this->idName];
-    }
-
-    public function save(): void
-    {
-        if (isset($this->attributes[$this->idName])) {
-            $this->update();
-        } else {
-            $this->insert();
-        }
-    }
-
-    public function delete(): void
-    {
-        if (!isset($this->attributes[$this->idName])) {
-            throw new \Exception('No primary key specified!');
-        }
-
-        $query = 'DELETE FROM ' . Utils::backtick($this->table) . ' WHERE ' . Utils::backtick($this->idName) . '=?';
-
-        $stmt = $this->connection->prepare($query);
-        $stmt->execute([$this->idName => $this->attributes[$this->idName]]);
-    }
-
-    private function insert(): void
-    {
-        if ($this->externalId !== null) {
-            $this->attributes[$this->idName] = $this->externalId;
-        } elseif (!$this->autoIncrement) {
-            $this->attributes[$this->idName] = $this->generateKey();
-        }
-
-        $set = $this->generateColumnsWithBinding(array_keys($this->attributes));
-
-        $query = 'INSERT INTO ' . Utils::backtick($this->table) . ' SET ' . $set;
-
-        $stmt = $this->connection->prepare($query);
-        $stmt->execute($this->attributes);
-
-        if ($this->autoIncrement) {
-            $this->attributes[$this->idName] = $this->connection->lastId();
-        }
-    }
-
-    private function update(): void
-    {
-        /*$diff = $this->generateDiff();
-
-        if (count($diff) === 0) {
-            return;
-        }*/
-
-        $diff = $this->attributes;
-        unset($diff[$this->idName]);
-
-        $set = $this->generateColumnsWithBinding(array_keys($diff));
-
-        $query = 'UPDATE ' . Utils::backtick($this->table) . ' SET ' . $set . ' WHERE ' . Utils::backtick($this->idName) . '=?';
-
-        $stmt = $this->connection->prepare($query);
-        $stmt->execute(array_merge($diff, [$this->idName => $this->attributes[$this->idName]]));
-    }
-
-    private function readFromDB(array $columns): void
-    {
-        $select = (new Select($this->connection, $this->table))
-            ->setIdName($this->idName)
-            ->whereId($this->attributes[$this->idName])
-            ->columns($columns);
-
-        $this->original = $select->execute()->fetch(IResultSet::FETCH_ASSOC);
-    }
-
-    private function generateDiff(): array
-    {
-        $this->readFromDB(array_keys($this->attributes));
-
-        $diff = [];
-
-        foreach ($this->attributes as $name => $value) {
-            $original = $this->original[$name];
-
-            if ($original != $value) {
-                $diff[$name] = $value;
-            }
-        }
-
-        return $diff;
-    }
-
-    public static function generateColumnsWithBinding(array $columns): string
-    {
-        array_walk($columns, function(&$value, $key) {
-            $value = Utils::backtick($value) . '=?';
-        });
-
-        return implode(',', $columns);
-    }
-
-    private function generateKey(): string
-    {
-        return substr(hash('sha256', serialize($this->attributes) . random_bytes(10) . microtime()), 0, 7);
-    }
-}

src/Database/Query/Select.php

@@ -1,402 +0,0 @@
-<?php namespace MapGuesser\Database\Query;
-
-use Closure;
-use MapGuesser\Interfaces\Database\IConnection;
-use MapGuesser\Interfaces\Database\IResultSet;
-use MapGuesser\Database\RawExpression;
-use MapGuesser\Database\Utils;
-
-class Select
-{
-    const CONDITION_WHERE = 0;
-
-    const CONDITION_HAVING = 1;
-
-    private IConnection $connection;
-
-    private string $table;
-
-    private string $idName = 'id';
-
-    private array $tableAliases = [];
-
-    private array $joins = [];
-
-    private array $columns = [];
-
-    private array $conditions = [self::CONDITION_WHERE => [], self::CONDITION_HAVING => []];
-
-    private array $groups = [];
-
-    private array $orders = [];
-
-    private array $limit;
-
-    public function __construct(IConnection $connection, string $table)
-    {
-        $this->connection = $connection;
-        $this->table = $table;
-    }
-
-    public function setIdName(string $idName): Select
-    {
-        $this->idName = $idName;
-
-        return $this;
-    }
-
-    public function setTableAliases(array $tableAliases): Select
-    {
-        $this->tableAliases = array_merge($this->tableAliases, $tableAliases);
-
-        return $this;
-    }
-
-    public function columns(array $columns): Select
-    {
-        $this->columns = array_merge($this->columns, $columns);
-
-        return $this;
-    }
-
-    public function innerJoin($table, $column1, string $relation, $column2): Select
-    {
-        $this->addJoin('INNER', $table, $column1, $relation, $column2);
-
-        return $this;
-    }
-
-    public function leftJoin($table, $column1, string $relation, $column2): Select
-    {
-        $this->addJoin('LEFT', $table, $column1, $relation, $column2);
-
-        return $this;
-    }
-
-    public function whereId($value): Select
-    {
-        $this->addWhereCondition('AND', $this->idName, '=', $value);
-
-        return $this;
-    }
-
-    public function where($column, string $relation = null, $value = null): Select
-    {
-        $this->addWhereCondition('AND', $column, $relation, $value);
-
-        return $this;
-    }
-
-    public function orWhere($column, string $relation = null, $value = null): Select
-    {
-        $this->addWhereCondition('OR', $column, $relation, $value);
-
-        return $this;
-    }
-
-    public function having($column, string $relation = null, $value = null): Select
-    {
-        $this->addHavingCondition('AND', $column, $relation, $value);
-
-        return $this;
-    }
-
-    public function orHaving($column, string $relation = null, $value = null): Select
-    {
-        $this->addHavingCondition('OR', $column, $relation, $value);
-
-        return $this;
-    }
-
-    public function groupBy($column): Select
-    {
-        $this->groups[] = $column;
-
-        return $this;
-    }
-
-    public function orderBy($column, string $type = 'ASC'): Select
-    {
-        $this->orders[] = [$column, $type];
-
-        return $this;
-    }
-
-    public function limit(int $limit, int $offset = 0): Select
-    {
-        $this->limit = [$limit, $offset];
-
-        return $this;
-    }
-
-    public function resetLimit(): void
-    {
-        $this->limit = null;
-    }
-
-    public function paginate(int $page, int $itemsPerPage)
-    {
-        $this->limit($itemsPerPage, ($page - 1) * $itemsPerPage);
-
-        return $this;
-    }
-
-    public function execute(): IResultSet
-    {
-        list($query, $params) = $this->generateQuery();
-
-        return $this->connection->prepare($query)->execute($params);
-    }
-
-    public function count(): int
-    {
-        if (count($this->groups) > 0 || count($this->conditions[self::CONDITION_HAVING]) > 0) {
-            $orders = $this->orders;
-
-            $this->orders = [];
-
-            list($query, $params) = $this->generateQuery();
-
-            $result = $this->connection->prepare('SELECT COUNT(*) num_rows FROM (' . $query . ') x')
-                ->execute($params)
-                ->fetch(IResultSet::FETCH_NUM);
-
-            $this->orders = $orders;
-
-            return $result[0];
-        } else {
-            $columns = $this->columns;
-            $orders = $this->orders;
-
-            $this->columns = [new RawExpression('COUNT(*) num_rows')];
-            $this->orders = [];
-
-            list($query, $params) = $this->generateQuery();
-
-            $result = $this->connection->prepare($query)
-                ->execute($params)
-                ->fetch(IResultSet::FETCH_NUM);
-
-            $this->columns = $columns;
-            $this->orders = $orders;
-
-            return $result[0];
-        }
-    }
-
-    private function addJoin(string $type, $table, $column1, string $relation, $column2): void
-    {
-        $this->joins[] = [$type, $table, $column1, $relation, $column2];
-    }
-
-    private function addWhereCondition(string $logic, $column, string $relation, $value): void
-    {
-        $this->conditions[self::CONDITION_WHERE][] = [$logic, $column, $relation, $value];
-    }
-
-    private function addHavingCondition(string $logic, $column, string $relation, $value): void
-    {
-        $this->conditions[self::CONDITION_HAVING][] = [$logic, $column, $relation, $value];
-    }
-
-    private function generateQuery(): array
-    {
-        $queryString = 'SELECT ' . $this->generateColumns() . ' FROM ' . $this->generateTable($this->table, true);
-
-        if (count($this->joins) > 0) {
-            $queryString .= ' ' . $this->generateJoins();
-        }
-
-        if (count($this->conditions[self::CONDITION_WHERE]) > 0) {
-            list($wheres, $whereParams) = $this->generateConditions(self::CONDITION_WHERE);
-
-            $queryString .= ' WHERE ' .  $wheres;
-        } else {
-            $whereParams = [];
-        }
-
-        if (count($this->groups) > 0) {
-            $queryString .= ' GROUP BY ' . $this->generateGroupBy();
-        }
-
-        if (count($this->conditions[self::CONDITION_HAVING]) > 0) {
-            list($havings, $havingParams) = $this->generateConditions(self::CONDITION_HAVING);
-
-            $queryString .= ' HAVING ' .  $havings;
-        } else {
-            $havingParams = [];
-        }
-
-        if (count($this->orders) > 0) {
-            $queryString .= ' ORDER BY ' . $this->generateOrderBy();
-        }
-
-        if (isset($this->limit)) {
-            $queryString .= ' LIMIT ' . $this->limit[1] . ', ' . $this->limit[0];
-        }
-
-        return [$queryString, array_merge($whereParams, $havingParams)];
-    }
-
-    private function generateTable($table, bool $defineAlias = false): string
-    {
-        if ($table instanceof RawExpression) {
-            return (string) $table;
-        }
-
-        if (isset($this->tableAliases[$table])) {
-            return ($defineAlias ? Utils::backtick($this->tableAliases[$table]) . ' ' . Utils::backtick($table) : Utils::backtick($table));
-        }
-
-        return Utils::backtick($table);
-    }
-
-    private function generateColumn($column): string
-    {
-        if ($column instanceof RawExpression) {
-            return (string) $column;
-        }
-
-        if (is_array($column)) {
-            $out = '';
-
-            if ($column[0]) {
-                $out .= $this->generateTable($column[0]) . '.';
-            }
-
-            $out .= Utils::backtick($column[1]);
-
-            if (!empty($column[2])) {
-                $out .= ' ' . Utils::backtick($column[2]);
-            }
-
-            return $out;
-        } else {
-            return Utils::backtick($column);
-        }
-    }
-
-    private function generateColumns(): string
-    {
-        $columns = $this->columns;
-
-        array_walk($columns, function (&$value, $key) {
-            $value = $this->generateColumn($value);
-        });
-
-        return implode(',', $columns);
-    }
-
-    private function generateJoins(): string
-    {
-        $joins = $this->joins;
-
-        array_walk($joins, function (&$value, $key) {
-            $value = $value[0] . ' JOIN ' . $this->generateTable($value[1], true) . ' ON ' . $this->generateColumn($value[2]) . ' ' . $value[3] . ' ' . $this->generateColumn($value[4]);
-        });
-
-        return implode(' ', $joins);
-    }
-
-    private function generateConditions(string $type): array
-    {
-        $conditions = '';
-        $params = [];
-
-        foreach ($this->conditions[$type] as $condition) {
-            list($logic, $column, $relation, $value) = $condition;
-
-            if ($column instanceof Closure) {
-                list($conditionsStringFragment, $paramsFragment) = $this->generateComplexConditionFragment($type, $column);
-            } else {
-                list($conditionsStringFragment, $paramsFragment) = $this->generateConditionFragment($condition);
-            }
-
-            if ($conditions !== '') {
-                $conditions .= ' ' . $logic . ' ';
-            }
-
-            $conditions .= $conditionsStringFragment;
-            $params = array_merge($params, $paramsFragment);
-        }
-
-        return [$conditions, $params];
-    }
-
-    private function generateConditionFragment(array $condition): array
-    {
-        list($logic, $column, $relation, $value) = $condition;
-
-        if ($column instanceof RawExpression) {
-            return [(string) $column, []];
-        }
-
-        $conditionsString = $this->generateColumn($column) . ' ';
-
-        if ($value === null) {
-            return [$conditionsString . ($relation == '=' ? 'IS NULL' : 'IS NOT NULL'), []];
-        }
-
-        $conditionsString .= strtoupper($relation) . ' ';;
-
-        switch ($relation = strtolower($relation)) {
-            case 'between':
-                $params = [$value[0], $value[1]];
-
-                $conditionsString .= '? AND ?';
-                break;
-
-            case 'in':
-            case 'not in':
-                $params = $value;
-
-                if (count($value) > 0) {
-                    $conditionsString .= '(' . implode(', ', array_fill(0, count($value), '?')) . ')';
-                } else {
-                    $conditionsString = $relation == 'in' ? '0' : '1';
-                }
-                break;
-
-            default:
-                $params = [$value];
-
-                $conditionsString .= '?';
-        }
-
-        return [$conditionsString, $params];
-    }
-
-    private function generateComplexConditionFragment(string $type, Closure $conditionCallback): array
-    {
-        $instance = new static($this->connection, $this->table);
-        $instance->tableAliases = $this->tableAliases;
-
-        $conditionCallback($instance);
-
-        list($conditions, $params) = $instance->generateConditions($type);
-
-        return ['(' . $conditions . ')', $params];
-    }
-
-    private function generateGroupBy(): string
-    {
-        $groups = $this->groups;
-
-        array_walk($groups, function (&$value, $key) {
-            $value = $this->generateColumn($value);
-        });
-
-        return implode(',', $groups);
-    }
-
-    private function generateOrderBy(): string
-    {
-        $orders = $this->orders;
-
-        array_walk($orders, function (&$value, $key) {
-            $value = $this->generateColumn($value[0]) . ' ' . strtoupper($value[1]);
-        });
-
-        return implode(',', $orders);
-    }
-}

src/Database/RawExpression.php

@@ -1,16 +0,0 @@
-<?php namespace MapGuesser\Database;
-
-class RawExpression
-{
-    private string $expression;
-
-    public function __construct(string $expression)
-    {
-        $this->expression = $expression;
-    }
-
-    public function __toString(): string
-    {
-        return $this->expression;
-    }
-}

src/Database/Utils.php

@@ -1,7 +0,0 @@
-<?php namespace MapGuesser\Database;
-
-class Utils {
-    public static function backtick(string $name) {
-        return '`' . $name . '`';
-    }
-}

src/Http/Request.php

@@ -1,93 +0,0 @@
-<?php namespace MapGuesser\Http;
-
-class Request
-{
-    const HTTP_GET = 0;
-
-    const HTTP_POST = 1;
-
-    private string $url;
-
-    private int $method;
-
-    private string $query = '';
-
-    private array $headers = [];
-
-    public function __construct(string $url, int $method = self::HTTP_GET)
-    {
-        $this->url = $url;
-        $this->method = $method;
-    }
-
-    public function setQuery($query)
-    {
-        if (is_string($query)) {
-            $this->query = $query;
-        } else {
-            $this->query = http_build_query($query);
-        }
-    }
-
-    public function setHeaders(array $headers)
-    {
-        $this->headers = array_merge($this->headers, $headers);
-    }
-
-    public function send(): Response
-    {
-        $ch = curl_init();
-
-        if ($this->method === self::HTTP_GET) {
-            $url = $this->url . '?' . $this->query;
-        } elseif ($this->method === self::HTTP_POST) {
-            $url  = $this->url;
-
-            curl_setopt($ch, CURLOPT_POST, 1);
-            curl_setopt($ch, CURLOPT_POSTFIELDS, $this->query);
-        }
-
-        curl_setopt($ch, CURLOPT_URL, $url);
-        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
-        curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
-        curl_setopt($ch, CURLOPT_TIMEOUT, 20);
-        curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
-        curl_setopt($ch, CURLOPT_USERAGENT, 'MapGuesser cURL/1.0');
-
-        if (count($this->headers) > 0) {
-            curl_setopt($ch, CURLOPT_HTTPHEADER, $this->headers);
-        }
-
-        $responseHeaders = [];
-        curl_setopt(
-            $ch,
-            CURLOPT_HEADERFUNCTION,
-            function ($ch, $header) use (&$responseHeaders) {
-                $len = strlen($header);
-                $header = explode(':', $header, 2);
-
-                if (count($header) < 2) {
-                    return $len;
-                }
-
-                $responseHeaders[strtolower(trim($header[0]))][] = trim($header[1]);
-
-                return $len;
-            }
-        );
-
-        $responseBody = curl_exec($ch);
-
-        if ($responseBody === false) {
-            $error = curl_error($ch);
-
-            curl_close($ch);
-
-            throw new \Exception($error);
-        }
-
-        curl_close($ch);
-
-        return new Response($responseBody, $responseHeaders);
-    }
-}

src/Http/Response.php

@@ -1,24 +0,0 @@
-<?php namespace MapGuesser\Http;
-
-class Response
-{
-    private string $body;
-
-    private array $headers;
-
-    public function __construct(string $body, array $headers)
-    {
-        $this->body = $body;
-        $this->headers = $headers;
-    }
-
-    public function getBody()
-    {
-        return $this->body;
-    }
-
-    public function getHeaders()
-    {
-        return $this->headers;
-    }
-}

src/Interfaces/Authentication/IUser.php

@@ -1,12 +0,0 @@
-<?php namespace MapGuesser\Interfaces\Authentication;
-
-interface IUser
-{
-    const PERMISSION_NORMAL = 0;
-
-    const PERMISSION_ADMIN = 1;
-
-    public function hasPermission(int $permission): bool;
-
-    public function getDisplayName(): string;
-}