diff --git a/.circleci/config.yml b/.circleci/config.yml
deleted file mode 100644
index a3ab9864..00000000
--- a/.circleci/config.yml
+++ /dev/null
@@ -1,108 +0,0 @@
-version: 2.1
-
-jobs:
-  client-suse-qt5-notests:
-    docker:
-      - image: kdeorg/ci-suse-qt515
-    steps:
-      - run:
-          name: Install KArchive
-          command: zypper -n install karchive-devel
-      - checkout
-      - run:
-          name: Cmake
-          command: mkdir build && cd build && cmake .. -DBUILD_ALL=OFF -DBUILD_CLIENT=ON -DQT_MAJOR_VERSION=5
-      - run:
-          name: Make
-          command: cd build && make cavoke_client
-  client-suse-qt6-notests:
-    docker:
-      - image: kdeorg/ci-suse-qt62
-    steps:
-      - checkout
-      - run:
-          name: Install KArchive
-          command: chmod +x .circleci/suse-qt6-install-karchive.sh && .circleci/suse-qt6-install-karchive.sh
-      - run:
-          name: Cmake
-          command: mkdir build && cd build && cmake .. -DBUILD_ALL=OFF -DBUILD_CLIENT=ON -DQT_MAJOR_VERSION=6  # QT_MAJOR_VERSION=6 by default, so not necessary
-      - run:
-          name: Make
-          command: cd build && make cavoke_client
-  server-docker-healthcheck:
-    docker:
-      - image: ghcr.io/cavoke-project/cavoke_ci:drogon # TODO: use circleci orbs
-        auth:
-          username: $GHCR_USERNAME
-          password: $GHCR_PASSWORD
-    steps:
-      - checkout
-      - run:
-          name: Cmake
-          command: mkdir build && cd build && cmake .. -DBUILD_ALL=OFF -DBUILD_SERVER=ON
-      - run:
-          name: Make
-          command: cd build && make cavoke_server
-      - run:
-          name: Simple healthcheck
-          command: chmod +x .circleci/server-test-health.py && .circleci/server-test-health.py ./build/server/cavoke_server
-  games-docker:
-    docker:
-      - image: ghcr.io/cavoke-project/cavoke_ci:drogon # TODO: use circleci orbs
-        auth:
-          username: $GHCR_USERNAME
-          password: $GHCR_PASSWORD
-    steps:
-      - checkout
-      - run:
-          name: Cmake
-          command: mkdir build && cd build && cmake .. -DBUILD_ALL=OFF -DBUILD_GAMES=ON
-      - run:
-          name: Make
-          command: cd build && make all
-  clangformat-master:
-    docker:
-      - image: ubuntu
-    steps:
-      - run:
-          name: Install Clangformat
-          command: apt update && apt install clang-format -y
-      - checkout
-      - run:
-          name: Clangformat
-          command: for file in $(find . -iname '*.cpp' -or -iname '*.c' -or -iname '*.h' -and -not -iname 'doctest.h' ); do diff -u <(cat "$file") <(clang-format "$file") || exit 1; done
-  clangtidy-master:
-    docker:
-      - image: ubuntu
-    steps:
-      - run:
-          name: Install Clang-tidy
-          command: apt update && apt install clang-tidy-12 -y
-      - checkout
-      - run:
-          name: Clang-tidy
-          command: clang-tidy-12 -extra-arg=-Iinclude  -extra-arg=-Idoctest $(find . -path '*/CMakeFiles/*' -prune -or \( -iname '*.cpp' -and -not -iname '*_test.cpp' -or -iname '*.h' -and -not -iname 'doctest.h' \) -print)
-  cppcheck-master:
-    docker:
-      - image: ubuntu
-    steps:
-      - run:
-          name: Install Cppcheck
-          command: apt update && apt install cppcheck -y
-      - checkout
-      - run:
-          name: Cppcheck
-          command: cppcheck --language=c++ -DSOME_DEFINE_TO_FIX_CONFIG --enable=all --suppress=*:doctest.h --suppress=unusedFunction --error-exitcode=1 --inline-suppr $(find . -iname '*.cpp')
-
-workflows:
-  app:
-    jobs:
-      - client-suse-qt5-notests
-      - client-suse-qt6-notests
-      - server-docker-healthcheck
-      - games-docker
-  codestyle:
-    jobs:
-      - clangformat-master
-#      - clangtidy-master
-      - cppcheck-master
\ No newline at end of file
diff --git a/.circleci/suse-qt6-install-karchive.sh b/.circleci/suse-qt6-install-karchive.sh
deleted file mode 100644
index 59eb2063..00000000
--- a/.circleci/suse-qt6-install-karchive.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env sh
-pushd $HOME
-# Install ECM
-zypper -n install extra-cmake-modules
-# Prepare KArchive
-git clone --branch v5.90.0 https://github.com/KDE/karchive  # FIXME: don't use specific version: currently ECM conflicts
-mkdir karchive/build
-cd karchive
-# Build 
-cd build
-cmake .. -DCMAKE_BUILD_TYPE=debug -DCMAKE_INSTALL_PREFIX=/usr/local -DQT_MAJOR_VERSION=6
-make
-make install
-popd
diff --git a/.craft.ini b/.craft.ini
new file mode 100644
index 00000000..90cb2fb2
--- /dev/null
+++ b/.craft.ini
@@ -0,0 +1,62 @@
+[General]
+Command = craft
+Branch = master
+ShallowClone = True
+
+# Variables defined here override the default value
+# The variable names are casesensitive
+[Variables]
+#Values need to be overwritten to create a chache
+UseCache = True
+CreateCache = True
+
+[GeneralSettings]
+Version/ConfigVersion = 6
+
+Packager/Destination=${Variables:WORKSPACE}/binaries
+Paths/Python = C:/Python36
+Paths/Python27 = C:/Python27
+Paths/DownloadDir = ${Variables:Root}/downloads
+ShortPath/Enabled = False
+Compile/BuildType = Release
+ContinuousIntegration/Enabled = True
+Packager/PackageDebugSymbols = False
+
+Packager/CacheDir = ${Variables:WORKSPACE}/cache
+Packager/UseCache = ${Variables:UseCache}
+Packager/CreateCache = ${Variables:CreateCache}
+
+[windows-msvc2019_64-cl]
+General/ABI = windows-msvc2019_64-cl
+
+[windows-msvc2019_64-cl-debug]
+General/ABI = windows-msvc2019_64-cl
+Compile/BuildType = Debug
+
+[windows-msvc2019_32-cl]
+General/ABI = windows-msvc2019_32-cl
+
+[macos-64-clang]
+General/ABI = macos-64-clang
+# Packager/PackageType = MacPkgPackager
+
+[macos-64-clang-debug]
+General/ABI = macos-64-clang
+Compile/BuildType = Debug
+
+[linux-64-gcc]
+General/ABI = linux-64-gcc
+
+[linux-64-gcc-BlueprintSettings]
+libs/dbus.ignored = False
+libs/qt5/qtbase.withDBus = True
+dev-utils/7zip.useCentosBasedBuild=True
+
+[linux-64-gcc-debug]
+General/ABI = linux-64-gcc
+Compile/BuildType = Debug
+
+[linux-64-gcc-debug-BlueprintSettings]
+libs/dbus.ignored = False
+libs/qt5/qtbase.withDBus = True
+dev-utils/7zip.useCentosBasedBuild=True
diff --git a/.craft.shelf b/.craft.shelf
new file mode 100644
index 00000000..1b7ce862
--- /dev/null
+++ b/.craft.shelf
@@ -0,0 +1,3 @@
+[General]
+version = 2
+blueprintrepositories = https://github.com/cavoke-project/craft-blueprints-cavoke.git|master|;https://invent.kde.org/packaging/craft-blueprints-kde.git|master|
\ No newline at end of file
diff --git a/.github/assets/cavoke-demo.gif b/.github/assets/cavoke-demo.gif
new file mode 100644
index 00000000..48a5bdc6
Binary files /dev/null and b/.github/assets/cavoke-demo.gif differ
diff --git a/.github/files/ci_server_config.json b/.github/files/ci_server_config.json
new file mode 100644
index 00000000..41415339
--- /dev/null
+++ b/.github/files/ci_server_config.json
@@ -0,0 +1,151 @@
+/* This is a JSON format configuration file
+ */
+{
+  //custom_config: custom configuration for users. This object can be acquired by the app().getCustomConfig() method.
+  "custom_config": {
+    "storage": {
+      "games_directory": "local_server/games",
+      "logic_name": "logic",
+      "zip_name": "client.zip",
+      "config_name": "config.json"
+    }
+  },
+  "db_clients": [
+    {
+      //name: Name of the client,'default' by default
+      "name": "default",
+      //rdbms: Server type, postgresql,mysql or sqlite3, "postgresql" by default
+      "rdbms": "postgresql",
+      //filename: Sqlite3 db file name
+      //"filename":"",
+      //host: Server address,localhost by default
+      "host": "127.0.0.1",
+      //port: Server port, 5432 by default
+      "port": 5432,
+      //dbname: Database name
+      "dbname": "cavoke",
+      //user: 'postgres' by default
+      "user": "postgres_user",
+      //passwd: '' by default
+      "passwd": "postgres_password",
+      //is_fast: false by default, if it is true, the client is faster but user can't call
+      //any synchronous interface of it.
+      "is_fast": false,
+      //client_encoding: The character set used by the client. it is empty string by default which
+      //means use the default character set.
+      //"client_encoding": "",
+      //number_of_connections: 1 by default, if the 'is_fast' is true, the number is the number of
+      //connections per IO thread, otherwise it is the total number of all connections.
+      "number_of_connections": 1,
+      //timeout: -1.0 by default, in seconds, the timeout for executing a SQL query.
+      //zero or negative value means no timeout.
+      "timeout": -1.0
+    }
+  ],
+  "app": {
+    //number_of_threads: The number of IO threads, 1 by default, if the value is set to 0, the number of threads
+    //is the number of CPU cores
+    "number_of_threads": 1,
+    //enable_session: False by default
+    "enable_session": false,
+    "session_timeout": 0,
+    //max_connections: maximum number of connections, 100000 by default
+    "max_connections": 100000,
+    //max_connections_per_ip: maximum number of connections per client, 0 by default which means no limit
+    "max_connections_per_ip": 0,
+    //Load_dynamic_views: False by default, when set to true, drogon
+    //compiles and loads dynamically "CSP View Files" in directories defined
+    //by "dynamic_views_path"
+    "load_dynamic_views": false,
+    //dynamic_views_path: If the path isn't prefixed with /, ./ or ../,
+    //it is relative path of document_root path
+    "dynamic_views_path": [
+      "./views"
+    ],
+    //dynamic_views_output_path: Default by an empty string which means the output path of source
+    //files is the path where the csp files locate. If the path isn't prefixed with /, it is relative
+    //path of the current working directory.
+    "dynamic_views_output_path": "",
+    //enable_unicode_escaping_in_json: true by default, enable unicode escaping in json.
+    "enable_unicode_escaping_in_json": true,
+    //float_precision_in_json: set precision of float number in json.
+    "float_precision_in_json": {
+      //precision: 0 by default, 0 means use the default precision of the jsoncpp lib.
+      "precision": 0,
+      //precision_type: must be "significant" or "decimal", defaults to "significant" that means
+      //setting max number of significant digits in string, "decimal" means setting max number of
+      //digits after "." in string
+      "precision_type": "significant"
+    },
+    //log: Set log output, drogon output logs to stdout by default
+    "log": {
+      //log_path: Log file path,empty by default,in which case,logs are output to the stdout
+      "log_path": "./",
+      //logfile_base_name: Log file base name,empty by default which means drogon names logfile as
+      //drogon.log ...
+      "logfile_base_name": "cavoke-server",
+      //log_size_limit: 100000000 bytes by default,
+      //When the log file size reaches "log_size_limit", the log file is switched.
+      "log_size_limit": 100000000,
+      //log_level: "DEBUG" by default,options:"TRACE","DEBUG","INFO","WARN"
+      //The TRACE level is only valid when built in DEBUG mode.
+      "log_level": "DEBUG"
+    },
+    //run_as_daemon: False by default
+    "run_as_daemon": false,
+    //handle_sig_term: True by default
+    "handle_sig_term": true,
+    //relaunch_on_error: False by default, if true, the program will be restarted by the parent after exiting;
+    "relaunch_on_error": false,
+    //use_sendfile: True by default, if true, the program
+    //uses sendfile() system-call to send static files to clients;
+    "use_sendfile": true,
+    //use_gzip: True by default, use gzip to compress the response body's content;
+    "use_gzip": true,
+    //use_brotli: False by default, use brotli to compress the response body's content;
+    "use_brotli": false,
+    //static_files_cache_time: 5 (seconds) by default, the time in which the static file response is cached,
+    //0 means cache forever, the negative value means no cache
+    "static_files_cache_time": 5,
+    //idle_connection_timeout: Defaults to 60 seconds, the lifetime
+    //of the connection without read or write
+    "idle_connection_timeout": 60,
+    //server_header_field: Set the 'Server' header field in each response sent by drogon,
+    //empty string by default with which the 'Server' header field is set to "Server: drogon/version string\r\n"
+    "server_header_field": "",
+    //enable_server_header: Set true to force drogon to add a 'Server' header to each HTTP response. The default
+    //value is true.
+    "enable_server_header": true,
+    //enable_date_header: Set true to force drogon to add a 'Date' header to each HTTP response. The default
+    //value is true.
+    "enable_date_header": true,
+    //keepalive_requests: Set the maximum number of requests that can be served through one keep-alive connection.
+    //After the maximum number of requests are made, the connection is closed.
+    //The default value of 0 means no limit.
+    "keepalive_requests": 0,
+    //pipelining_requests: Set the maximum number of unhandled requests that can be cached in pipelining buffer.
+    //After the maximum number of requests are made, the connection is closed.
+    //The default value of 0 means no limit.
+    "pipelining_requests": 0,
+    //gzip_static: If it is set to true, when the client requests a static file, drogon first finds the compressed
+    //file with the extension ".gz" in the same path and send the compressed file to the client.
+    //The default value of gzip_static is true.
+    "gzip_static": true,
+    //br_static: If it is set to true, when the client requests a static file, drogon first finds the compressed
+    //file with the extension ".br" in the same path and send the compressed file to the client.
+    //The default value of br_static is true.
+    "br_static": true,
+    //client_max_body_size: Set the maximum body size of HTTP requests received by drogon. The default value is "1M".
+    //One can set it to "1024", "1k", "10M", "1G", etc. Setting it to "" means no limit.
+    "client_max_body_size": "1M",
+    //max_memory_body_size: Set the maximum body size in memory of HTTP requests received by drogon. The default value is "64K" bytes.
+    //If the body size of an HTTP request exceeds this limit, the body is stored to a temporary file for processing.
+    //Setting it to "" means no limit.
+    "client_max_memory_body_size": "64K",
+    //client_max_websocket_message_size: Set the maximum size of messages sent by WebSocket client. The default value is "128K".
+    //One can set it to "1024", "1k", "10M", "1G", etc. Setting it to "" means no limit.
+    "client_max_websocket_message_size": "128K",
+    //reuse_port: Defaults to false, users can run multiple processes listening on the same port at the same time.
+    "reuse_port": false
+  }
+}
diff --git a/.github/scripts/.craft.ps1 b/.github/scripts/.craft.ps1
new file mode 100644
index 00000000..8925247f
--- /dev/null
+++ b/.github/scripts/.craft.ps1
@@ -0,0 +1,13 @@
+if ($IsWindows) {
+    $python = (Get-Command py).Source
+} else {
+    $python = (Get-Command python3).Source
+}
+$command = @("${env:HOME}/craft/CraftMaster/CraftMaster/CraftMaster.py",
+             "--config", "${env:GITHUB_WORKSPACE}/.craft.ini",
+             "--target", "${env:CRAFT_TARGET}",
+             "--variables", "WORKSPACE=${env:HOME}/craft") + $args
+
+Write-Host "Exec: ${python} ${command}"
+
+& $python @command
\ No newline at end of file
diff --git a/.github/scripts/diff-clangformat-12.sh b/.github/scripts/diff-clangformat-12.sh
new file mode 100644
index 00000000..08fb2202
--- /dev/null
+++ b/.github/scripts/diff-clangformat-12.sh
@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+diff -u --from-file "$1" <(clang-format-12 "$1") && exit 0 || exit 1
diff --git a/.circleci/server-test-health.py b/.github/scripts/server-test-health.py
similarity index 76%
rename from .circleci/server-test-health.py
rename to .github/scripts/server-test-health.py
index 254efcd8..493299d0 100644
--- a/.circleci/server-test-health.py
+++ b/.github/scripts/server-test-health.py
@@ -14,13 +14,13 @@ def check_eq(expected, actual):
 
 
 def main():
-    _, *server_cmd = sys.argv
-    assert server_cmd, 'Expected usage: ./server-test-health.py <command-to-run>'
+    server_cmds = sys.argv[1:]
+    assert server_cmds, 'Expected usage: ./server-test-health.py <command-to-run> <args>'
 
     port = 8080
-    print(f'Booting server... at {server_cmd}', flush=True)
+    print(f'Booting server... at {server_cmds[0]}', flush=True)
 
-    server = subprocess.Popen(args=[*server_cmd, '-p', str(port)])
+    server = subprocess.Popen(args=server_cmds + ['-p', str(port)])
     def kill_server():
         try:
             server.wait(timeout=0.1)
diff --git a/.github/workflows/app.yml b/.github/workflows/app.yml
new file mode 100644
index 00000000..1a0f0c5b
--- /dev/null
+++ b/.github/workflows/app.yml
@@ -0,0 +1,14 @@
+name: Cavoke
+on:
+  push
+jobs:
+  tests:
+    uses: ./.github/workflows/tests.yml
+  bundle-client:
+    needs: [tests]
+    uses: ./.github/workflows/bundle-client-craft.yml
+  deploy-server-develop:
+    if: github.ref == 'refs/heads/develop'
+    needs: [tests]
+    uses: ./.github/workflows/deploy-server-develop.yml
+    secrets: inherit
diff --git a/.github/workflows/bundle-client-craft.yml b/.github/workflows/bundle-client-craft.yml
new file mode 100644
index 00000000..ce4dd53d
--- /dev/null
+++ b/.github/workflows/bundle-client-craft.yml
@@ -0,0 +1,113 @@
+# Originally from: https://raw.githubusercontent.com/owncloud/client/9ef42e4faa56367d99e31b5cc3e5f91da9b865f7/.github/workflows/main.yml
+
+name: Bundle Client
+on: workflow_call
+
+defaults:
+  run:
+    shell: pwsh
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        include:
+          - name: Windows 64-bit cl
+            target: windows-msvc2019_64-cl
+            os: windows-latest
+            fetch-depth: 0
+            container:
+          - name: macOS 64-bit clang
+            target: macos-64-clang
+            os: macos-latest
+            fetch-depth: 1
+            container:
+          - name: CentOS 7 64-bit gcc
+            target: linux-64-gcc
+            os: ubuntu-latest
+            container: kdeorg/centos7-craft
+            fetch-depth: 1
+      fail-fast: false
+
+    name: ${{ matrix.name }}
+
+    runs-on: ${{ matrix.os }}
+
+    env:
+      CRAFT_TARGET: ${{ matrix.target }}
+
+    container: ${{ matrix.container }}
+
+    steps:
+      - name: Check out source code
+        uses: actions/checkout@v2
+        with:
+          submodules: recursive
+
+      - name: Restore cache
+        uses: actions/cache@v2
+        with:
+          path: ~/craft/cache
+          key: ${{ runner.os }}-${{ matrix.target }}-v3
+
+      - name: Clone CraftMaster
+        run: git clone --depth=1 https://invent.kde.org/kde/craftmaster.git "$env:HOME/craft/CraftMaster/CraftMaster"
+
+      - name: Craft setup
+        run: |
+          New-Item -Path ~/cache -ItemType Directory -ErrorAction SilentlyContinue
+          & "${env:GITHUB_WORKSPACE}/.github/scripts/.craft.ps1" --setup
+      - name: Craft unshelve
+        run: |
+          & "${env:GITHUB_WORKSPACE}/.github/scripts/.craft.ps1" -c --unshelve "${env:GITHUB_WORKSPACE}/.craft.shelf"
+      - name: Prepare
+        run: |
+          if ($IsWindows) {
+              & "${env:GITHUB_WORKSPACE}/.github/scripts/.craft.ps1" -c dev-utils/nsis
+          } elseif($IsLinux) {
+              & "${env:GITHUB_WORKSPACE}/.github/scripts/.craft.ps1" -c dev-utils/linuxdeploy
+              & "${env:GITHUB_WORKSPACE}/.github/scripts/.craft.ps1" -c --set enableLibcloudproviders=true cavoke
+          }
+      - name: Install dependencies
+        run: |
+          & "${env:GITHUB_WORKSPACE}/.github/scripts/.craft.ps1" -c --install-deps cavoke
+      - name: Build
+        run: |
+          & "${env:GITHUB_WORKSPACE}/.github/scripts/.craft.ps1" -c --no-cache --src-dir "${env:GITHUB_WORKSPACE}" cavoke
+      - name: Package
+        run: |
+          & "${env:GITHUB_WORKSPACE}/.github/scripts/.craft.ps1" -c --no-cache --src-dir "${env:GITHUB_WORKSPACE}" --package cavoke
+      - name: Prepare artifacts
+        run: |
+          New-Item -ItemType Directory "${env:GITHUB_WORKSPACE}/binaries/" -ErrorAction SilentlyContinue
+          Copy-Item "$env:HOME/craft/binaries/*" "${env:GITHUB_WORKSPACE}/binaries/"
+          & "${env:GITHUB_WORKSPACE}/.github/scripts/.craft.ps1" -c --shelve "${env:GITHUB_WORKSPACE}/.craft.shelf"
+          Copy-Item "${env:GITHUB_WORKSPACE}/.craft.shelf" "${env:GITHUB_WORKSPACE}/binaries/"
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: ${{ matrix.name }}
+          path: ${{ github.workspace }}/binaries/*
+  create-release:
+    name: Create Release
+    needs: [ build ]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - name: Download all workflow run artifacts
+        uses: actions/download-artifact@v3
+      - name: Rename files
+        run: |
+          find -name '*.exe' -exec mv '{}' './cavoke-${{ github.ref_name }}-windows.exe' ';'
+          find -name '*.dmg' -exec mv '{}' './cavoke-${{ github.ref_name }}-macos.dmg' ';'
+          find -name '*.AppImage' -exec mv '{}' './cavoke-${{ github.ref_name }}-linux.AppImage' ';'
+      - name: GitHub Release
+        uses: softprops/action-gh-release@v1
+        with:
+          name: Release ${{ github.ref_name }}
+          draft: true
+          files: |
+            cavoke-*-windows.exe
+            cavoke-*-macos.dmg
+            cavoke-*-linux.AppImage
+          fail_on_unmatched_files: true
diff --git a/.github/workflows/deploy-server-develop.yml b/.github/workflows/deploy-server-develop.yml
new file mode 100644
index 00000000..62f0c2fc
--- /dev/null
+++ b/.github/workflows/deploy-server-develop.yml
@@ -0,0 +1,54 @@
+name: Deploy server (development version)
+on: workflow_call
+jobs:
+  server-publish-image-develop:
+    runs-on: ubuntu-latest
+    #    environment: develop
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Build and push
+        uses: docker/build-push-action@v2
+        with:
+          file: server.Dockerfile
+          push: true
+          tags: ghcr.io/cavoke-project/cavoke-server:latest  # TODO: different tag for different branches
+  server-deploy-cloud-run-develop:
+    runs-on: ubuntu-latest
+    environment:
+      name: develop
+      url: https://develop.api.cavoke.wlko.me
+    concurrency: develop
+    needs: [ server-publish-image-develop ]
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Setup Cloud SDK
+        uses: google-github-actions/setup-gcloud@v0
+        with:
+          project_id: ${{ env.PROJECT_ID }}
+          service_account_key: ${{ secrets.GCP_SA_KEY }}
+          export_default_credentials: true
+      - name: 'Deploy to Cloud Run'
+        run: |
+          gcloud components install beta && \
+          gcloud beta run deploy cavoke-server-develop \
+            --execution-environment gen2 \
+            --source server/.gcp \
+            --allow-unauthenticated \
+            --service-account ${{ env.SERVICE_ACCOUNT }} \
+            --region=${{ env.REGION }} \
+            --update-env-vars BUCKET=${{ env.BUCKET_NAME }}
+env:
+  PROJECT_ID: waleko-personal
+  SERVICE_ACCOUNT: fs-identity
+  BUCKET_NAME: cavoke-test-1
+  REGION: europe-north1
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 00000000..1aa84b7e
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,129 @@
+name: Run Tests
+on:
+  workflow_call
+jobs:
+  clang-format:
+    name: ClangFormat 12
+    runs-on: ubuntu-latest
+    container: ghcr.io/cavoke-project/cavoke-ci:codeql
+    timeout-minutes: 1
+    steps:
+      - uses: actions/checkout@v2
+        # do not check submodules
+      - run: clang-format-12 --version
+      - run: chmod +x .github/scripts/diff-clangformat-12.sh && find . \( -iname '*.cpp' -or -iname '*.c' -or -iname '*.h' \) -and -not -path './server/models/*' | xargs -n1 .github/scripts/diff-clangformat-12.sh
+  cppcheck:
+    name: Cppcheck
+    runs-on: ubuntu-latest
+    container: ghcr.io/cavoke-project/cavoke-ci:codeql
+    timeout-minutes: 1
+    steps:
+      - uses: actions/checkout@v2
+        # do not check submodules
+      - run: cppcheck --version
+      - run: cppcheck --language=c++ -DSOME_DEFINE_TO_FIX_CONFIG --enable=all --suppress=*:doctest.h --suppress=unusedFunction --error-exitcode=1 --inline-suppr $(find . -iname '*.cpp' -and -not -path './server/models/*')
+  client-notests-qt5-suse:
+    runs-on: ubuntu-latest
+    container: ghcr.io/cavoke-project/cavoke-ci:client-qt5-suse
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Cmake
+        run: mkdir build && cd build && cmake .. -DBUILD_ALL=OFF -DBUILD_CLIENT=ON -DQT_MAJOR_VERSION=5
+      - name: Make
+        run: cd build && make cavoke_client
+  client-notests-qt6-suse:
+    runs-on: ubuntu-latest
+    container: ghcr.io/cavoke-project/cavoke-ci:client-qt6-suse
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Cmake
+        run: mkdir build && cd build && cmake .. -DBUILD_ALL=OFF -DBUILD_CLIENT=ON -DQT_MAJOR_VERSION=6  # QT_MAJOR_VERSION=6 by default, so not necessary
+      - name: Make
+        run: cd build && make cavoke_client
+  server-compiles-with-submodules:
+    runs-on: ubuntu-latest
+    steps:
+      - run: sudo apt-get update && sudo apt-get install -y openssl libssl-dev libjsoncpp-dev uuid-dev zlib1g-dev libc-ares-dev postgresql-server-dev-all libboost-all-dev
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Cmake
+        run: mkdir build && cd build && cmake .. -DBUILD_ALL=OFF -DBUILD_SERVER=ON
+      - name: Make
+        run: cd build && make cavoke_server
+  server-healthcheck:
+    runs-on: ubuntu-latest
+    container: ghcr.io/cavoke-project/cavoke-ci:server
+    services:
+      postgres:
+        image: postgres:latest
+        env:
+          POSTGRES_DB: cavoke
+          POSTGRES_PASSWORD: postgres_password
+          POSTGRES_PORT: 5432
+          POSTGRES_USER: postgres_user
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Install PostgreSQL client
+        run: |
+          apt-get update
+          apt-get install --yes postgresql-client
+      - name: Populate the database
+        run: psql -h postgres -d cavoke -U postgres_user -f server/db/schema.sql
+        env:
+          PGPASSWORD: postgres_password
+      - name: Cmake
+        run: mkdir build && cd build && cmake .. -DBUILD_ALL=OFF -DBUILD_SERVER=ON -DUSE_EXTERNAL_DROGON=ON -DUSE_EXTERNAL_NLOHMANN=ON -DUSE_EXTERNAL_JWT=ON
+      - name: Make
+        run: cd build && make cavoke_server
+      - name: Healthcheck
+        run: chmod +x .github/scripts/server-test-health.py && .github/scripts/server-test-health.py ./build/server/cavoke_server -c .github/files/ci_server_config.json
+  server-tests:
+    runs-on: ubuntu-latest
+    container: ghcr.io/cavoke-project/cavoke-ci:server
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Cmake
+        run: mkdir build && cd build && cmake .. -DBUILD_ALL=OFF -DBUILD_SERVER=ON -DUSE_EXTERNAL_DROGON=ON -DUSE_EXTERNAL_NLOHMANN=ON -DUSE_EXTERNAL_JWT=ON
+      - name: Make
+        run: cd build && make cavoke_server_test
+      - name: Run Tests
+        run: ./build/server/test/cavoke_server_test
+  games-notests:
+    runs-on: ubuntu-latest
+    container: ghcr.io/cavoke-project/cavoke-ci:server
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Cmake
+        run: mkdir build && cd build && cmake .. -DBUILD_ALL=OFF -DBUILD_GAMES=ON -DUSE_EXTERNAL_DROGON=ON -DUSE_EXTERNAL_NLOHMANN=ON -DUSE_EXTERNAL_JWT=ON
+      - name: Make
+        run: cd build && make all
+  server-docker-compose-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+        with:
+          submodules: recursive
+      - name: Start up the server with Docker Compose
+        run: docker-compose up -d
+      - name: Healthcheck
+        run: test $(curl -s localhost:8080/health) = "OK"
+      - name: Check that some games are available
+        run: curl -s localhost:8080/games/list | jq -e 'length >= 1'
diff --git a/.gitignore b/.gitignore
index 0ad14463..91f47cd5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -172,4 +172,10 @@ fabric.properties
 
 .idea/
 
+# Local game files
 local_server/
+
+# Drogon logs
+*.log
+/games/codenames/client/client.zip
+uploads/
\ No newline at end of file
diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 00000000..203384c8
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,21 @@
+[submodule "third_party/drogon"]
+	path = third_party/drogon
+	url = https://github.com/drogonframework/drogon.git
+[submodule "third_party/json"]
+	path = third_party/json
+	url = https://github.com/nlohmann/json.git
+[submodule "third_party/qtkeychain"]
+	path = third_party/qtkeychain
+	url = https://github.com/frankosterfeld/qtkeychain.git
+[submodule "third_party/jwt"]
+    path = third_party/jwt
+    url = https://github.com/Thalhammer/jwt-cpp.git
+[submodule "third_party/extra-cmake-modules"]
+	path = third_party/extra-cmake-modules
+	url = https://github.com/kde/extra-cmake-modules
+[submodule "third_party/karchive"]
+	path = third_party/karchive
+	url = https://github.com/kde/karchive
+[submodule "third_party/zlib"]
+	path = third_party/zlib
+	url = https://github.com/madler/zlib
diff --git a/.gitpod.Dockerfile b/.gitpod.Dockerfile
new file mode 100644
index 00000000..54c16038
--- /dev/null
+++ b/.gitpod.Dockerfile
@@ -0,0 +1,10 @@
+FROM gitpod/workspace-full
+
+RUN sudo apt-get update -yqq \
+    && sudo apt-get install -yqq --no-install-recommends software-properties-common \
+    openssl libssl-dev libjsoncpp-dev uuid-dev zlib1g-dev libc-ares-dev\
+    postgresql-server-dev-all \
+    libboost-all-dev python3-pip \
+    qtbase5-dev qtdeclarative5-dev libqt5networkauth5-dev\
+    libkf5archive-dev \
+    && sudo rm -rf /var/lib/apt/lists/*
diff --git a/.gitpod.yml b/.gitpod.yml
new file mode 100644
index 00000000..fa0c2fa6
--- /dev/null
+++ b/.gitpod.yml
@@ -0,0 +1,25 @@
+image:
+  file: .gitpod.Dockerfile
+
+tasks:
+  - name: Database
+    before: docker build . -f db.Dockerfile -t cavoke_db
+    command: docker run -t -p 5432:5432 -e POSTGRES_USER=postgres_user -e POSTGRES_PASSWORD=postgres_password cavoke_db
+  - name: Cmake
+    init: mkdir -p build-cmake && cmake . -B build-cmake -DQT_MAJOR_VERSION=5
+
+vscode:
+  extensions:
+    - ms-azuretools.vscode-docker
+    - timonwong.shellcheck
+#    - ms-vscode.cmake-tools
+    - vscode.cpp
+
+github:
+  prebuilds:
+    master: true
+    branches: true
+    pullRequests: true
+    pullRequestsFromForks: true
+    addCheck: true
+    addComment: true
\ No newline at end of file
diff --git a/.postman/collections/Cavoke REST API_950ad167-dd3a-4311-a8a5-3099ffd73b61.json b/.postman/collections/Cavoke REST API_950ad167-dd3a-4311-a8a5-3099ffd73b61.json
deleted file mode 100644
index f7fc4fc4..00000000
--- a/.postman/collections/Cavoke REST API_950ad167-dd3a-4311-a8a5-3099ffd73b61.json	
+++ /dev/null
@@ -1,225 +0,0 @@
-{
-    "info": {
-        "_postman_id": "2b66a0c3-22a1-481a-83c6-68178c907d8a",
-        "name": "Cavoke REST API",
-        "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
-    },
-    "item": [
-        {
-            "name": "Simple health check",
-            "id": "db43eafc-7c04-4bd0-81c3-9d775eee7020",
-            "request": {
-                "method": "GET",
-                "header": [],
-                "url": {
-                    "raw": "{{baseUrl}}/health",
-                    "host": [
-                        "{{baseUrl}}"
-                    ],
-                    "path": [
-                        "health"
-                    ]
-                }
-            },
-            "response": []
-        },
-        {
-            "name": "List available games to play",
-            "id": "47f80185-289c-418b-971d-7397c1e1c2aa",
-            "request": {
-                "method": "GET",
-                "header": [],
-                "url": {
-                    "raw": "{{baseUrl}}/games/list",
-                    "host": [
-                        "{{baseUrl}}"
-                    ],
-                    "path": [
-                        "games",
-                        "list"
-                    ]
-                }
-            },
-            "response": []
-        },
-        {
-            "name": "Get GameInfo of specific game",
-            "id": "53aa843d-ce79-4ffd-9c93-8a89a08738b5",
-            "request": {
-                "method": "GET",
-                "header": [],
-                "url": {
-                    "raw": "{{baseUrl}}/games/:game_id/get_config",
-                    "host": [
-                        "{{baseUrl}}"
-                    ],
-                    "path": [
-                        "games",
-                        ":game_id",
-                        "get_config"
-                    ],
-                    "variable": [
-                        {
-                            "id": "2788ef7c-a640-4c9f-a4cf-b157a7460bfe",
-                            "key": "game_id",
-                            "value": "deserunt voluptate culpa",
-                            "description": "(Required) String id of the game to get"
-                        }
-                    ]
-                }
-            },
-            "response": []
-        },
-        {
-            "name": "Download QML client zip of a game",
-            "id": "5b5e67c5-ab56-4966-81dc-a703521bced0",
-            "request": {
-                "method": "GET",
-                "header": [],
-                "url": {
-                    "raw": "{{baseUrl}}/games/:game_id/get_client",
-                    "host": [
-                        "{{baseUrl}}"
-                    ],
-                    "path": [
-                        "games",
-                        ":game_id",
-                        "get_client"
-                    ],
-                    "variable": [
-                        {
-                            "id": "3cc760b2-83e2-4d0d-883d-5ab622b69967",
-                            "key": "game_id",
-                            "value": "deserunt voluptate culpa",
-                            "description": "(Required) String id of the game to get"
-                        }
-                    ]
-                }
-            },
-            "response": [
-                {
-                    "id": "669d21ec-5471-4b7e-80a4-cccded3ee4b4",
-                    "name": "Client zip file of an existing game",
-                    "originalRequest": {
-                        "method": "GET",
-                        "header": [],
-                        "url": {
-                            "raw": "{{baseUrl}}/games/:game_id/get_client",
-                            "host": [
-                                "{{baseUrl}}"
-                            ],
-                            "path": [
-                                "games",
-                                ":game_id",
-                                "get_client"
-                            ],
-                            "variable": [
-                                {
-                                    "key": "game_id",
-                                    "value": "deserunt voluptate culpa",
-                                    "description": "(Required) String id of the game to get"
-                                }
-                            ]
-                        }
-                    },
-                    "status": "OK",
-                    "code": 200,
-                    "_postman_previewlanguage": "Text",
-                    "header": [
-                        {
-                            "key": "Content-Type",
-                            "value": "application/octet-stream"
-                        }
-                    ],
-                    "cookie": [],
-                    "responseTime": null,
-                    "body": "qui labore"
-                },
-                {
-                    "id": "49473878-b93d-40ef-9f6d-34658fbebfaa",
-                    "name": "No such game",
-                    "originalRequest": {
-                        "method": "GET",
-                        "header": [],
-                        "url": {
-                            "raw": "{{baseUrl}}/games/:game_id/get_client",
-                            "host": [
-                                "{{baseUrl}}"
-                            ],
-                            "path": [
-                                "games",
-                                ":game_id",
-                                "get_client"
-                            ],
-                            "variable": [
-                                {
-                                    "key": "game_id",
-                                    "value": "deserunt voluptate culpa",
-                                    "description": "(Required) String id of the game to get"
-                                }
-                            ]
-                        }
-                    },
-                    "status": "Not Found",
-                    "code": 404,
-                    "_postman_previewlanguage": "Text",
-                    "header": [
-                        {
-                            "key": "Content-Type",
-                            "value": "text/plain"
-                        }
-                    ],
-                    "cookie": [],
-                    "responseTime": null,
-                    "body": ""
-                },
-                {
-                    "id": "a239fae8-9480-4921-a2b2-080413f7cb85",
-                    "name": "Unexpected error",
-                    "originalRequest": {
-                        "method": "GET",
-                        "header": [],
-                        "url": {
-                            "raw": "{{baseUrl}}/games/:game_id/get_client",
-                            "host": [
-                                "{{baseUrl}}"
-                            ],
-                            "path": [
-                                "games",
-                                ":game_id",
-                                "get_client"
-                            ],
-                            "variable": [
-                                {
-                                    "key": "game_id",
-                                    "value": "deserunt voluptate culpa",
-                                    "description": "(Required) String id of the game to get"
-                                }
-                            ]
-                        }
-                    },
-                    "status": "Internal Server Error",
-                    "code": 500,
-                    "_postman_previewlanguage": "Text",
-                    "header": [
-                        {
-                            "key": "Content-Type",
-                            "value": "application/json"
-                        }
-                    ],
-                    "cookie": [],
-                    "responseTime": null,
-                    "body": "{\n \"code\": -33611818,\n \"message\": \"Excepteur ut nulla\"\n}"
-                }
-            ]
-        }
-    ],
-    "variable": [
-        {
-            "id": "f7afe901-2417-48e1-8d98-b7e71978434e",
-            "key": "baseUrl",
-            "value": "localhost:8080",
-            "type": "string"
-        }
-    ]
-}
\ No newline at end of file
diff --git a/.postman/schemas/schema.yaml b/.postman/schemas/schema.yaml
deleted file mode 100644
index c7f098eb..00000000
--- a/.postman/schemas/schema.yaml
+++ /dev/null
@@ -1,290 +0,0 @@
-openapi: 3.0.0
-info:
-  version: '0.0.3'
-  title: 'cavoke'
-servers:
-  - url: 'localhost:8080'
-paths:
-  /health:
-    get:
-      summary: 'Simple health check'
-      operationId: health
-      responses:
-        '200':
-          description: 'OK'
-          content:
-            text/plain:
-              schema:
-                type: string
-                example: OK
-
-  /games/list:
-    get:
-      summary: 'List available games to play'
-      operationId: listGames
-      responses:
-        '200':
-          description: 'List of available games as metadata'
-          content:
-            application/json:
-              schema:
-                type: array
-                items:
-                  $ref: "#/components/schemas/GameInfo"
-        default:
-          description: Unexpected error
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/Error'
-  /games/{game_id}/get_config:
-    get:
-      summary: 'Get GameInfo of specific game'
-      operationId: configGame
-      parameters:
-        - in: path
-          name: game_id
-          schema:
-            $ref: '#/components/schemas/GameId'
-          required: true
-          description: 'String id of the game to get'
-          example: tictactoe
-      responses:
-        '200':
-          description: 'Config of an existing game'
-          content:
-            application/json:
-              schema:
-                $ref: "#/components/schemas/GameInfo"
-        '404':
-          description: 'No such game'
-        default:
-          description: Unexpected error
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/Error'
-  /games/{game_id}/get_client:
-    get:
-      summary: 'Download QML client zip of a game'
-      operationId: downloadClient
-      parameters:
-        - in: path
-          name: game_id
-          schema:
-            $ref: '#/components/schemas/GameId'
-          required: true
-          description: 'String id of the game to get'
-          example: 'tictactoe'
-      responses:
-        '200':
-          description: 'Client zip file of an existing game'
-          content:
-            application/octet-stream:
-              schema:
-                type: string
-                format: binary
-        '404':
-          description: 'No such game'
-        default:
-          description: Unexpected error
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/Error'
-  /sessions/create:
-    post:
-      summary: 'Create a game from requested game'
-      operationId: createSession
-      parameters:
-        - in: query
-          name: game_id
-          schema:
-            $ref: '#/components/schemas/GameId'
-          required: true
-          description: 'String id of the game to get'
-          example: tictactoe
-        - in: query
-          name: user_id
-          schema:
-            $ref: '#/components/schemas/UserId'
-          required: true
-          description: 'User id'
-          example: c84d0d6e-547a-4e3a-92ba-5a6ff6c3d51f
-      responses:
-        '200':
-          description: 'Created successfully'
-          content:
-            application/json:
-              schema:
-                type: object
-                properties:
-                  game_id:
-                    $ref: '#/components/schemas/GameId'
-                  session_id:
-                    $ref: '#/components/schemas/SessionId'
-        '400':
-          description: 'Bad request'
-        '404':
-          description: 'No game with such game id'
-        default:
-          description: Unexpected error
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/Error'
-
-  /play/{session_id}/send_move:
-    post:
-      summary: 'Send a move from QML game'
-      operationId: sendMove
-      parameters:
-        - in: path
-          name: session_id
-          schema:
-            $ref: '#/components/schemas/SessionId'
-          required: true
-          example: 83896dd5-6f03-4805-8cf1-03ce6bd6077f
-        - in: query
-          name: user_id
-          schema:
-            $ref: '#/components/schemas/UserId'
-          required: true
-          description: 'User id'
-          example: c84d0d6e-547a-4e3a-92ba-5a6ff6c3d51f
-      requestBody:
-        description: Game move data
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/GameMove'
-      responses:
-        '200':
-          description: 'Move accepted'
-
-        '404':
-          description: 'No such session / no such user'
-        default:
-          description: Unexpected error
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/Error'
-  /play/{session_id}/get_update:
-    get:
-      summary: 'Try get an update from QML game'
-      operationId: getUpdate
-      tags:
-        - play
-      parameters:
-        - in: path
-          name: session_id
-          schema:
-            type: string
-            format: uuid
-          required: true
-          description: 'UUID of a game session (room to game pair)'
-        - in: query
-          name: user_id
-          schema:
-            $ref: '#/components/schemas/UserId'
-          required: true
-          description: 'User id'
-          example: c84d0d6e-547a-4e3a-92ba-5a6ff6c3d51f
-        - in: query
-          name: offset
-          schema:
-            type: integer
-            format: int32
-          example: 32
-          description: 'Only get updates after this id (by default 0, so returns all updates throught the game)'
-      responses:
-        '200':
-          description: 'List updates (in an ascending order of ids)'
-          content:
-            application/json:
-              schema:
-                type: array
-                items:
-                  $ref: "#/components/schemas/GameUpdate"
-        '404':
-          description: 'No such session / no such user'
-        default:
-          description: Unexpected error
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/Error'
-
-components:
-  schemas:
-    GameId:
-      type: string
-      example: tictactoe
-    GameInfo:
-      type: object
-      required:
-        - id
-        - display_name
-        - description
-        - players_num
-      properties:
-        id:
-          $ref: '#/components/schemas/GameId'
-        display_name:
-          type: string
-        description:
-          type: string
-        players_num:
-          type: integer
-          format: int32
-    Error:
-      type: object
-      required:
-        - code
-        - message
-      properties:
-        code:
-          type: integer
-          format: int32
-          example: 31
-        message:
-          type: string
-          example: 'Something went wrong'
-    GameMove:
-      type: object
-      properties:
-        move:
-          type: string
-          description: 'Any information about the move supplied by QML. May be any string (e.g. JSON)'
-      required:
-        - user_id
-        - move
-    GameUpdate:
-      type: object
-      properties:
-        user_id:
-          type: string
-          format: uuid
-          example: c84d0d6e-547a-4e3a-92ba-5a6ff6c3d51f
-        update:
-          type: string
-          description: "Any information about the update supplied by app's logic. May be any string (e.g. JSON)"
-          example: '{"action": "x_move", x: 0, y: 2}'
-        id:
-          type: integer
-          format: int32
-          example: 1
-      required:
-        - user_id
-        - update
-    SessionId:
-      type: string
-      format: uuid
-      example: 83896dd5-6f03-4805-8cf1-03ce6bd6077f
-  securitySchemes:
-    BasicAuth:
-      type: http
-      scheme: basic
-# security:
-#  - BasicAuth: []
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index fdba859f..6a62bea7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,12 +1,75 @@
 cmake_minimum_required(VERSION 3.10)
 project(cavoke)
 
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
 option(BUILD_ALL "Build all subprojects (usually disabled for ci)" ON)
 
 option(BUILD_SERVER "Enable building server" OFF)
 option(BUILD_CLIENT "Enable building client" OFF)
 option(BUILD_GAMES "Enable building games" OFF)
 
+# Add local drogon
+if (BUILD_ALL OR BUILD_SERVER OR BUILD_GAMES)
+    option(USE_EXTERNAL_DROGON "Whether to use external drogon" OFF)
+    if (USE_EXTERNAL_DROGON)
+        message("Using external Drogon...")
+        find_package(Drogon 1.7.3 REQUIRED)
+    else ()
+        message("Using Drogon from submodules...")
+        if (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/drogon/CMakeLists.txt)
+            message(SEND_ERROR "Unable to add a dependency locally!\nHave you tried running:  git submodule update --init --recursive")
+        endif ()
+        add_subdirectory(third_party/drogon)
+    endif ()
+
+    option(USE_EXTERNAL_JWT "Whether to use external jwt-cpp" OFF)
+    if (USE_EXTERNAL_JWT)
+        message("Using external jwt-cpp...")
+        # https://github.com/Thalhammer/jwt-cpp JWT authentication
+        find_package(jwt-cpp REQUIRED)
+    else ()
+        message("Using JWT from submodules...")
+        if (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/jwt/CMakeLists.txt)
+            message(SEND_ERROR "Unable to add a dependency locally!\nHave you tried running:  git submodule update --init --recursive")
+        endif ()
+        # HACK: workaround for a windows bug https://github.com/kazuho/picojson/issues/141
+        set(JWT_BUILD_EXAMPLES OFF)
+        set(JWT_DISABLE_PICOJSON ON)
+        add_subdirectory(third_party/jwt)
+    endif ()
+endif ()
+
+# Add local nlohmann
+if (BUILD_ALL OR BUILD_SERVER OR BUILD_GAMES)
+    option(USE_EXTERNAL_NLOHMANN "Whether to use external nlohmann_json" OFF)
+    if (USE_EXTERNAL_NLOHMANN)
+        message("Using external Nlohmann...")
+        # https://github.com/nlohmann/json/releases/tag/v3.9.0 for convenience macros
+        find_package(nlohmann_json 3.9.0 REQUIRED)
+    else ()
+        message("Using Nlohmann from submodules...")
+        if (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/json/CMakeLists.txt)
+            message(SEND_ERROR "Unable to add a dependency locally!\nHave you tried running:  git submodule update --init --recursive")
+        endif ()
+        add_subdirectory(third_party/json)
+    endif ()
+endif ()
+
+## Add local qtkeychain
+#if (BUILD_ALL OR BUILD_CLIENT)
+#    message("Using Qtkeychain from submodules...")
+#    if (NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/third_party/qtkeychain/CMakeLists.txt)
+#        message(SEND_ERROR "Unable to add a dependency locally!\nHave you tried running:  git submodule update --init --recursive")
+#    endif()
+#    if (QT_MAJOR_VERSION EQUAL 6)
+#        set(BUILD_WITH_QT6 ON)
+#    endif ()
+#    add_subdirectory(third_party/qtkeychain)
+#endif()
+
 if (BUILD_ALL OR BUILD_SERVER)
     add_subdirectory(server)
 endif ()
@@ -16,3 +79,4 @@ endif ()
 if (BUILD_ALL OR BUILD_GAMES)
     add_subdirectory(games)
 endif ()
+
diff --git a/CNAME b/CNAME
new file mode 100644
index 00000000..a888d9b7
--- /dev/null
+++ b/CNAME
@@ -0,0 +1 @@
+cavoke.wlko.me
\ No newline at end of file
diff --git a/GameLogicProtocol.md b/GameLogicProtocol.md
index 82d45ac1..bcff9e4a 100644
--- a/GameLogicProtocol.md
+++ b/GameLogicProtocol.md
@@ -4,7 +4,7 @@
 
 ### GameState
 Состояние игры, возвращаемое игровой логикой.
-```json lines
+```jsonc lines
 {
   // закончена ли игра
   "is_terminal": bool,
@@ -25,7 +25,7 @@
 
 ### GameMove
 Ход игрока, передаваемый игровой логике
-```json lines
+```jsonc lines
 {
   // номер игрока (в рамках данной партии)
   // если равно -1 - инициализация новой сессии (остальные поля не имеют значения)
diff --git a/README.md b/README.md
index 95928ec0..be75bddf 100644
--- a/README.md
+++ b/README.md
@@ -1,24 +1,277 @@
-<a href="https://github.com/cavoke-project/cavoke">
-  <img align="left" height="80px" src="https://avatars.githubusercontent.com/u/52053547?s=200&v=4">
-</a>
-<h1 style="display: inline;">
+<h1 align="center">
+  <br>
+  <a href="https://cavoke.wlko.me"><img src="https://avatars.githubusercontent.com/u/52053547?s=200&v=4" alt="Cavoke" width="200"></a>
+  <br>
   Cavoke
+  <br>
 </h1>
 
-<p>Платформа для создания и проведения сетевых пошаговых настольных игр</p>
+<h4 align="center">A Platform for creating and hosting multiplayer turn-based board games</h4>
+
+<p align="center">
+    <a href="https://github.com/cavoke-project/cavoke/actions/workflows/app.yml">
+        <img alt="GitHub Workflow Status" src="https://img.shields.io/github/workflow/status/cavoke-project/cavoke/app?style=flat-square&logo=github">
+    </a>
+<!--
+    <a href="https://github.com/cavoke-project/cavoke/releases">
+        <img alt="GitHub release (latest by date including pre-releases)" src="https://img.shields.io/github/v/release/cavoke-project/cavoke?include_prereleases&logo=github&style=flat-square">
+    </a>
+-->
+    <a href="">
+        <img alt="GitHub deployments" src="https://img.shields.io/github/deployments/cavoke-project/cavoke/develop?label=deployment&logo=google-cloud&logoColor=white&style=flat-square">
+    </a>
+    <a href="https://ghcr.io/cavoke-project/cavoke-server:latest">
+        <img alt="Docker available" src="https://img.shields.io/badge/docker-available-success?style=flat-square&logo=docker&logoColor=white">
+    </a>
+    <a href="https://cavoke.docs.apiary.io">
+        <img alt="OpenAPI status" src="https://img.shields.io/badge/OpenAPI-passing-success?logo=swagger&logoColor=white&style=flat-square">
+    </a>
+    <!--<a href="https://gitpod.io/#https://github.com/cavoke-project/cavoke">
+        <img alt="Gitpod Ready-to-Code" src="https://img.shields.io/badge/Gitpod-Ready--to--Code-orange?logo=gitpod&style=flat-square">
+    </a>-->
+    <a href="./LICENSE">
+        <img alt="License" src="https://img.shields.io/github/license/cavoke-project/cavoke?style=flat-square&color=6ad">
+    </a>
+</p>
+<p align="center">
+<a href="https://github.com/cavoke-project/cavoke/releases">
+  <img alt="GitHub release (latest by date including pre-releases)" src="https://img.shields.io/badge/DOWNLOAD-windows%20%7C%20macos%20%7C%20linux-blue?style=for-the-badge">
+</a>
+<a href="https://console.cavoke.wlko.me">
+<img alt="Browse available games" src="https://img.shields.io/badge/browse-available%20games-red?style=for-the-badge">
+</a>
+  
+</p>
+
+<p align="center">
+  <a href="#overview">Overview</a> •
+  <a href="#how-to-use">How To Use</a> •
+  <a href="#download">Download</a> •
+  <a href="#credits">Credits</a> •
+  <a href="#license">License</a>
+</p>
+
+<!-- TODO: replace gif -->
+![screenshot](https://raw.githubusercontent.com/cavoke-project/cavoke/develop/.github/assets/cavoke-demo.gif)
+
+## Overview
+
+### Problem formulation
+
+We believe that developing a desktop multiplayer game is always a great adventure that has many wonderful opportunities
+to learn something new along the way.
+However, in our opinion this journey, is often riddled with unnecessary challenges of implementing mechanisms that are
+common for many games. This includes:
+
+- Developing a **client application** with many UI components for game creation process
+- **Networking**, which in itself includes
+  - **Synchronizing the game state** among clients
+  - Handling network issues on client's side
+  - SSL and Security
+- **Game state persistence**
+- **Game move validation**
+- **Role choosing** (e.g. White/Black in Chess)
+- Managing **game sessions** and **shareable invites* for friends to play with you
+- **Game and User statistics** (win rate, total time spent, etc.)
+- User **Authentication and Authorization**
+- Game versioning
+- Hosting server logic and scalability
+
+To make these obstacles easier to avoid, we developed a framework for developing multiplayer turn-based board games
+that comes with built-in solutions to solve all the above-mentioned problems.
+
+### Our solution
+#### Developers side
+
+Our platform provides an easy way for developers to create a desktop game. A developer should provide only two
+components:
+
+- **Server logic component** that verifies one's move correctness and updates the game state
+- **Client game component**. A [QML](https://doc.qt.io/qt-6/qmlapplications.html) application that communicates with the
+  main Cavoke Client application and sends player's moves through this gateway. It also receives updates from other
+  players' moves to update its user interface.
+
+<details>
+  <summary>Example Cavoke Game Development Story (Tic-Tac-Toe)</summary>
+
+Let's see how a simple Tic-Tac-Toe game using our Cavoke platform may look like. See files for this
+example [here](./games/tictactoe) and [here](./client/tictactoe-files)
+. <!-- TODO: Put tictactoe into a separate repo -->
+
+We start off with the client-side. We create a simple QML application and design our game UI. Now it's time to connect
+our QML component to the main cavoke Qt application:
+
+```qml
+...
+import "content/interactions.js" as Interact
+
+Rectangle {
+    // BEGIN cavoke section
+    Connections {
+        target: cavoke
+
+        function onReceiveUpdate(jsonUpdate) { // <-- Signal that handles incoming game states
+            console.log("Received: " + jsonUpdate);
+            Interact.processResponse(jsonUpdate);
+        }
+    }
+    // END cavoke section
+
+    id: game
+...
+```
+
+And in the `interactions.js`:
+
+```js
+function processResponse(response) { // <-- Processes the received state from the server
+  let res = JSON.parse(response)
+  updateBoard(res["state"]); // Parses the game state UI.
+                             // Here res["state"] may look something like "XOO OX X "
+}
+
+function sendMove(moveString) {
+  let move = {}
+  move.move = "X" + moveString
+  cavoke.getMoveFromQml(JSON.stringify(move)) // <-- Sends data to the server via Qt
+}
+
+function updateBoard(boardString) {
+  for (let i = 0; i < 9; ++i) {
+    board.children[i].state = boardString[i];
+  }
+}
+
+// ...
+```
+
+Developers may decide for themselves how their states will look. They may use json, plain-string, base64. It just has to
+be representable as a string. For example, the developers of this game decided to encode the game state as a json
+with `state` field that is 9 characters long representing the tictactoe board, i.e. `XOO OX X ` would represent the
+following field.
+
+```
+XOO
+ OX
+ X 
+```
+
+> :information_source: Notice that QML game component doesn't include any networking, session management, users
+> authentication, etc. All of this is handled by the main cavoke client executable. Developers can focus solely on their
+> game.
+> That's it with the client side! All the other bits and bobs around QML component have to do with UI and not
+> administrating the game process.
+
+Now let's see what awaits us on the server side.
+
+A server component must be able to handle 3 requests.
+
+- `VALIDATE` – Check if received game configuration can be used to start it (e.g. minimum players count reached, at
+  least 1 player in every team, etc.)
+- `INIT` – Create a game session using given configuration. Generates game state for this session. Now players can play.
+- `MOVE` – Process user's move (figure move in Chess, new X/O in Tic-Tac-Toe, etc.)
+
+> :warning: Server components also have to be *stateless*, because they may be shut down and restarted at any point
+> without notice. This means that all game session information must be stored in the game state that is passed onto the
+> server component with every `MOVE` request.
+
+So for Tic-Tac-Toe we have something like this:
+
+```cpp
+bool validate_settings( // <-- Validates game configuration
+    const json &settings,
+    const std::vector<int> &occupied_positions,
+    const std::function<void(std::string)> &message_callback) {
+    if (occupied_positions.size() != 2) {
+        message_callback("Not enough players");
+        return false;
+    }
+    if (!settings.contains("board_size")) {
+        message_callback("No board_size property");
+        return false;
+    }
+    if (settings["board_size"].get<int>() != 3) {
+        message_callback("Only  board_size=3 is supported");
+        return false;
+    }
+    return true;
+}
+// ...
+GameState init_state(const json &settings, // <-- Creates a game session
+                     const std::vector<int> &occupied_positions) {
+    int board_size = settings["board_size"];
+    std::string board(board_size * board_size, ' ');
+    return GameState{false, board, {board, board}, {}};
+}
+// ...
+GameState apply_move(GameMove &new_move) { /// <-- Handles move request
+    std::string &board = new_move.global_state;
+    char player = (new_move.player_id == 0 ? 'X' : 'O');
+    if (player != current_player(board)) {
+        return {false, board, {board, board}, {}};
+    }
+    int position = extract_position(new_move.move);
+    if (!is_valid_move(board, position)) {
+        return {false, board, {board, board}, {}};
+    }
+    board[position] = player;
+    bool win = winner(board);
+    std::vector<int> winners;
+    if (win) {
+        winners.push_back(new_move.player_id);
+    }
+    return {win, board, {board, board}, winners};
+}
+```
+
+> :information_source: You can read more about all the game logic protocol [here](./GameLogicProtocol.md)
+  </details>
+
+#### Players side
+Futhermore, we provide many features in our cavoke client for the users. These include:
+- **Cross platform**: Available on Windows, macOS and Linux
+- **User Authentication** using Email-Password or SSO via Google or GitHub
+- **Catalog of available cavoke games**
+- **Rooms** with shareable invites for your friends, so you can play multiple games without the need to change the app
+- **User's statistics** for every game
+- **Developer mode** to test QML components locally
+
+## How To Use
+
+Please see the instructions for how to clone and build server and client components in its subdirectories.
+
+- [Server](./server)
+- [Client](./client)
+
+## Download
+
+You can [download](https://github.com/cavoke-project/cavoke/releases/) the latest installable version of Cavoke Client
+for Windows, macOS and Linux.
+
+## Credits
+
+This software uses the following open source projects:
+
+- [Qt](https://www.qt.io/)
+- [Drogon](https://github.com/drogonframework/drogon)
+- [Circle Icons](https://www.iconfinder.com/iconsets/circle-icons-1) by Nick Roach
+- [Boost](https://www.boost.org/)
+- [KArchive](https://github.com/KDE/karchive)
+- [KDE Craft](https://github.com/KDE/Craft)
+- [ECM](https://github.com/KDE/extra-cmake-modules)
+- [jwt-cpp](https://github.com/Thalhammer/jwt-cpp)
+- [qtkeychain](https://github.com/frankosterfeld/qtkeychain)
+- [nlohmann/json](https://github.com/nlohmann/json)
+- [Quassel](https://github.com/quassel/quassel)
 
-[![CircleCI Build Status](https://img.shields.io/circleci/build/github/cavoke-project/cavoke?style=flat-square)](https://app.circleci.com/pipelines/github/cavoke-project/cavoke?filter=all)
-[![GitHub top language](https://img.shields.io/github/languages/top/cavoke-project/cavoke?logo=github&style=flat-square)](https://github.com/cavoke-project/cavoke)
-[![license](https://img.shields.io/github/license/cavoke-project/cavoke?style=flat-square)](./LICENSE)
+Credit to [Mudlet](https://github.com/Mudlet/Mudlet) and [Markdownify](https://github.com/amitmerchant1990/electron-markdownify) for the README inspiration.
 
-## Что это
-Cavoke – платформа для создания и проведения сетевых пошаговых настольных игр: позволяет разработчику не думать о создании комнат, подключении игроков, передаче данных от сервера к клиентам. Состоит из сервера и игрового клиента (отвечает за запуск интерфейсов игр). 
+## License
 
-Разработчик игры регистрирует свой игровой продукт на нашей платформе, предоставляет компоненты с серверной и игровой логикой. Игрок, посредством приложения Cavoke клиента, получает доступ к зарегистрированным в системе играм и может играть в них один и по сети. Cavoke клиент при запуске игры  запрашивает компонент выбранной игры с сервера, загружает и запускает его на компьютере игрока, предоставляя им доступ к игровому опыту.
+[MIT](./LICENSE)
 
-<!-- TODO -->
+---
 
-## Подмодули
-- [client](/client) – Десктопный клиент на Qt
-- [server](/server) – Сервер на Drogon, запускающий логику игр
-- [games](/games) – Реализованные игры
+> [@MarkTheHopeful](https://github.com//MarkTheHopeful) &nbsp;&middot;&nbsp;
+> [@waleko](https://github.com/waleko) &nbsp;&middot;&nbsp;
+> [@petrtsv](https://github.com/petrtsv) 
diff --git a/_config.yml b/_config.yml
new file mode 100644
index 00000000..3083ae5e
--- /dev/null
+++ b/_config.yml
@@ -0,0 +1,2 @@
+theme: jekyll-theme-cayman
+exclude: third_party/
diff --git a/games/cavoke.cpp b/cavoke-dev-lib/cavoke.cpp
similarity index 100%
rename from games/cavoke.cpp
rename to cavoke-dev-lib/cavoke.cpp
diff --git a/games/cavoke.h b/cavoke-dev-lib/cavoke.h
similarity index 100%
rename from games/cavoke.h
rename to cavoke-dev-lib/cavoke.h
diff --git a/cavoke-dev-server-lib/cavoke.cpp b/cavoke-dev-server-lib/cavoke.cpp
new file mode 100644
index 00000000..0a1b0cf2
--- /dev/null
+++ b/cavoke-dev-server-lib/cavoke.cpp
@@ -0,0 +1,79 @@
+#include <drogon/drogon.h>
+#include <boost/algorithm/string/join.hpp>
+#include <boost/program_options.hpp>
+#include <boost/range/adaptor/transformed.hpp>
+#include "controllers/logic_controller.h"
+
+namespace cavoke::logic_server {
+
+void run(const std::string &ip, uint16_t port) {
+    auto &app = drogon::app();
+
+    app.addListener(ip, port);
+
+    // print db and listeners on start
+    app.registerBeginningAdvice([]() {
+        auto listeners = drogon::app().getListeners();
+        std::string ips =
+            listeners.empty()
+                ? "<NO LISTENERS>"
+                : boost::join(
+                      listeners | boost::adaptors::transformed(
+                                      [](const trantor::InetAddress &e) {
+                                          return e.toIpPort();
+                                      }),
+                      ", ");
+        std::cout << "Listening at " << ips << "... " << std::endl;
+    });
+
+    app.registerPostHandlingAdvice([](const drogon::HttpRequestPtr &req,
+                                      const drogon::HttpResponsePtr &resp) {
+        // cors header for every response
+        resp->addHeader("Access-Control-Allow-Origin", "*");
+    });
+
+    auto logic_controller = std::make_shared<controllers::LogicController>();
+
+    app.registerController(logic_controller);
+
+    app.run();
+}
+
+}  // namespace cavoke::logic_server
+
+namespace po = boost::program_options;
+
+int main(int argc, char *argv[]) {
+    po::options_description desc("Allowed options");
+    auto add_desc_options = desc.add_options();
+    add_desc_options("help,h", "Print help");
+    add_desc_options("ip,i", po::value<std::string>()->default_value("0.0.0.0"),
+                     "IP address for connection");
+    add_desc_options("port,p", po::value<uint16_t>()->default_value(9090),
+                     "TCP/IP port number for connection");
+
+    po::variables_map vm;
+    po::store(po::parse_command_line(argc, argv, desc), vm);
+    po::notify(vm);
+
+    if (vm.count("help")) {
+        std::cout << desc << "\n";
+        return 0;
+    }
+
+    // defaults
+    std::string ip = "0.0.0.0";
+    uint16_t port = 9090;
+
+    if (vm.count("ip")) {
+        ip = vm["ip"].as<std::string>();
+    }
+
+    if (vm.count("port")) {
+        port = vm["port"].as<uint16_t>();
+    }
+
+    cavoke::logic_server::run(ip, port);
+
+    return 0;
+}
diff --git a/cavoke-dev-server-lib/cavoke.h b/cavoke-dev-server-lib/cavoke.h
new file mode 100644
index 00000000..bbae56e3
--- /dev/null
+++ b/cavoke-dev-server-lib/cavoke.h
@@ -0,0 +1,64 @@
+#ifndef CAVOKE_CAVOKE_H
+#define CAVOKE_CAVOKE_H
+
+#include <iostream>
+#include <nlohmann/json.hpp>
+#include <string>
+#include <vector>
+
+// TODO: logging
+namespace cavoke {
+using json = nlohmann::json;
+
+struct GameState {  // NOLINT(cppcoreguidelines-pro-type-member-init)
+    bool is_terminal;
+    std::string global_state;
+    std::vector<std::string> players_state;
+    std::vector<int> winners;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameState,
+                                   is_terminal,
+                                   global_state,
+                                   players_state,
+                                   winners)
+
+struct GameMove {  // NOLINT(cppcoreguidelines-pro-type-member-init)
+    int player_id;
+    std::string move;
+    std::string global_state;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameMove, player_id, move, global_state)
+
+struct InitSettings {
+    json settings;
+    std::vector<int> occupied_positions;
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(InitSettings, settings, occupied_positions);
+
+struct ValidationResult {
+    bool success;
+    std::string message;
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(ValidationResult, success, message);
+
+// called every time admin changes settings or new player arrives
+// returns true if game can be started with current settings; false otherwise
+// use message_callback(<some_message>) to display message to the players
+bool validate_settings(
+    const json &settings,
+    const std::vector<int> &occupied_positions,
+    const std::function<void(std::string)> &message_callback);
+
+// called once when the game session is started
+// generates initial state
+// settings have passed the validation
+GameState init_state(const json &settings,
+                     const std::vector<int> &occupied_positions);
+
+// applies move to the state
+GameState apply_move(GameMove &new_move);
+
+}  // namespace cavoke
+
+#endif  // CAVOKE_CAVOKE_H
diff --git a/cavoke-dev-server-lib/controllers/logic_controller.cpp b/cavoke-dev-server-lib/controllers/logic_controller.cpp
new file mode 100644
index 00000000..7c10a37d
--- /dev/null
+++ b/cavoke-dev-server-lib/controllers/logic_controller.cpp
@@ -0,0 +1,70 @@
+#include "logic_controller.h"
+#include <nlohmann/json.hpp>
+#include "../cavoke.h"
+#include "../utils.h"
+
+namespace cavoke::logic_server::controllers {
+
+using json = nlohmann::json;
+
+void LogicController::validate(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    std::cout << "GOT REQUEST " << req->getBody() << std::endl;
+    try {
+        InitSettings settings = json::parse(req->getBody());
+        ValidationResult result;
+
+        result.success = cavoke::validate_settings(
+            settings.settings, settings.occupied_positions,
+            [&result](const std::string &message) {
+                result.message = message;
+            });
+
+        std::cout << "SENT RESPONSE " << json(result).dump() << std::endl;
+        callback(newNlohmannJsonResponse(result));
+    } catch (const json::parse_error &) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    } catch (const json::out_of_range &) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+}
+
+void LogicController::init_state(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    std::cout << "GOT REQUEST " << req->getBody() << std::endl;
+    try {
+        InitSettings settings = json::parse(req->getBody());
+
+        GameState result =
+            cavoke::init_state(settings.settings, settings.occupied_positions);
+
+        std::cout << "SENT RESPONSE " << json(result).dump() << std::endl;
+        callback(newNlohmannJsonResponse(result));
+    } catch (const json::parse_error &) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    } catch (const json::out_of_range &) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+}
+
+void LogicController::apply_move(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    std::cout << "GOT REQUEST " << req->getBody() << std::endl;
+    try {
+        GameMove move = json::parse(req->getBody());
+
+        GameState result = cavoke::apply_move(move);
+
+        std::cout << "SENT RESPONSE " << json(result).dump() << std::endl;
+        callback(newNlohmannJsonResponse(result));
+    } catch (const json::parse_error &) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    } catch (const json::out_of_range &) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+}
+
+}  // namespace cavoke::logic_server::controllers
diff --git a/cavoke-dev-server-lib/controllers/logic_controller.h b/cavoke-dev-server-lib/controllers/logic_controller.h
new file mode 100644
index 00000000..7ac948af
--- /dev/null
+++ b/cavoke-dev-server-lib/controllers/logic_controller.h
@@ -0,0 +1,32 @@
+#ifndef CAVOKE_STATE_CONTROLLER_H
+#define CAVOKE_STATE_CONTROLLER_H
+
+#include <drogon/HttpController.h>
+
+namespace cavoke::logic_server::controllers {
+
+class LogicController : public drogon::HttpController<LogicController, false> {
+public:
+    METHOD_LIST_BEGIN
+    ADD_METHOD_TO(LogicController::validate, "/validate", drogon::Post);
+    ADD_METHOD_TO(LogicController::init_state, "/init_state", drogon::Post);
+    ADD_METHOD_TO(LogicController::apply_move, "/apply_move", drogon::Post);
+    METHOD_LIST_END
+
+protected:
+    void validate(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+
+    void init_state(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+
+    void apply_move(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+};
+
+}  // namespace cavoke::logic_server::controllers
+
+#endif  // CAVOKE_STATE_CONTROLLER_H
diff --git a/cavoke-dev-server-lib/utils.h b/cavoke-dev-server-lib/utils.h
new file mode 100644
index 00000000..5879ba74
--- /dev/null
+++ b/cavoke-dev-server-lib/utils.h
@@ -0,0 +1,38 @@
+#ifndef CAVOKE_UTILS_H
+#define CAVOKE_UTILS_H
+
+#include <drogon/HttpResponse.h>
+#include <boost/filesystem/path.hpp>
+#include <nlohmann/json.hpp>
+#include <regex>
+
+namespace cavoke::logic_server::controllers {
+
+/**
+ * Creates a drogon response from serializable object.
+ *
+ * Preferably pass the object itself, not the json object,
+ * because `nlohmann::json{configs}` adds extra square brackets to objects
+ * see https://github.com/cavoke-project/cavoke/issues/22. Avoid curly braces.
+ */
+inline drogon::HttpResponsePtr newNlohmannJsonResponse(
+    const nlohmann::json &obj) {
+    auto res = drogon::HttpResponse::newHttpResponse();
+    res->setContentTypeCode(drogon::CT_APPLICATION_JSON);
+    res->setBody(obj.dump());
+    return res;
+}
+
+/// Creates blank http response with given status code
+inline drogon::HttpResponsePtr newStatusCodeResponse(
+    const drogon::HttpStatusCode &status_code) {
+    auto res = drogon::HttpResponse::newHttpResponse();
+    res->setStatusCode(status_code);
+    return res;
+}
+
+#define CALLBACK_STATUS_CODE(code) \
+    callback(newStatusCodeResponse(::drogon::code))
+}  // namespace cavoke::logic_server::controllers
+
+#endif  // CAVOKE_UTILS_H
diff --git a/client/AuthenticationManager.cpp b/client/AuthenticationManager.cpp
new file mode 100644
index 00000000..b2ce3578
--- /dev/null
+++ b/client/AuthenticationManager.cpp
@@ -0,0 +1,142 @@
+#include "AuthenticationManager.h"
+#include <QDesktopServices>
+#include <QOAuthHttpServerReplyHandler>
+#include <QUrlQuery>
+#include <QtDebug>
+
+//#if defined(INCLUDE_OWN_QT_KEYCHAIN)
+//#include "keychain.h"
+//#else
+//#include <qt5keychain/keychain.h>
+//#endif
+
+void cavoke::auth::AuthenticationManager::init() {
+    oauth2.setAuthorizationUrl(QUrl(authorizationUrl));
+    oauth2.setAccessTokenUrl(QUrl(accessTokenUrl));
+    oauth2.setClientIdentifier(clientId);
+    oauth2.setScope(scope);
+
+    connect(&oauth2, &QOAuth2AuthorizationCodeFlow::statusChanged,
+            [=](QAbstractOAuth::Status status) {
+                if (status == QAbstractOAuth::Status::Granted) {
+                    qDebug() << "Now authenticated!!";
+                    writeSecurePassword(refresh_token_profile,
+                                        oauth2.refreshToken());
+                    if (oauth2.token().isEmpty()) {
+                        qWarning() << "Authentication completed successfully, "
+                                      "but token is empty!! Forcing a relogin";
+                        relogin();
+                    }
+                    emit authenticated();
+                } else if (status == QAbstractOAuth::Status::NotAuthenticated) {
+                    qWarning() << "Unauthenticated";
+                }
+            });
+    oauth2.setModifyParametersFunction(
+        [&](QAbstractOAuth::Stage stage, auto *parameters) {
+            if (stage == QAbstractOAuth::Stage::RequestingAuthorization)
+                parameters->insert("audience", audience);
+        });
+    connect(&oauth2, &QOAuth2AuthorizationCodeFlow::authorizeWithBrowser, this,
+            [&](const QUrl &url) {
+                // logout link with redirect to authorization
+                QUrl route{logoutUrl};
+                route.setQuery(QUrlQuery{
+                    {"returnTo", QUrl::toPercentEncoding(url.toEncoded())}});
+                QDesktopServices::openUrl(route);
+            });
+    readSecurePassword(refresh_token_profile,
+                       [&](const QString &refresh_token) {
+                           qDebug() << "Loaded refresh token from Keychain!";
+                           oauth2.setRefreshToken(refresh_token);
+                           oauth2.refreshAccessToken();
+                       });
+}
+bool cavoke::auth::AuthenticationManager::checkAuthStatus() {
+    return !oauth2.token().isEmpty();
+}
+void cavoke::auth::AuthenticationManager::writeSecurePassword(
+    const QString &profile,
+    const QString &pass) {
+    // FIXME: move to qkeychain
+    settings.setValue(profile, pass);
+    //    auto *job = new QKeychain::WritePasswordJob("cavoke_keychain");
+    //    job->setAutoDelete(false);
+    //    job->setInsecureFallback(false);
+    //    job->setKey(profile);
+    //    job->setTextData(pass);
+    //    connect(job, &QKeychain::WritePasswordJob::finished, this,
+    //            [](QKeychain::Job *job) {
+    //                if (job->error()) {
+    //                    qWarning() << job->errorString();
+    //                }
+    //                job->deleteLater();
+    //            });
+    //    job->start();
+}
+template <typename L>
+void cavoke::auth::AuthenticationManager::readSecurePassword(
+    const QString &profile,
+    L callback) {
+    // FIXME: move to qkeychain
+    callback(settings.value(profile).toString());
+    //    auto *job = new QKeychain::ReadPasswordJob("cavoke_keychain");
+    //    job->setAutoDelete(false);
+    //    job->setInsecureFallback(false);
+    //    job->setKey(profile);
+    //    connect(job, &QKeychain::ReadPasswordJob::finished, this,
+    //            [=](QKeychain::Job *job) {
+    //                if (job->error()) {
+    //                    qWarning() << job->errorString();
+    //                }
+    //                auto readJob = dynamic_cast<QKeychain::ReadPasswordJob
+    //                *>(job); callback(readJob->textData());
+    //                job->deleteLater();
+    //            });
+    //    job->start();
+}
+void cavoke::auth::AuthenticationManager::deleteSecurePassword(
+    const QString &profile) {
+    // FIXME: move to qkeychain
+    settings.setValue(profile, "");
+    //    auto *job = new QKeychain::DeletePasswordJob("cavoke_keychain");
+    //    job->setAutoDelete(false);
+    //    job->setInsecureFallback(false);
+    //    job->setKey(profile);
+    //    job->setProperty("profile", profile);
+    //    connect(job, &QKeychain::WritePasswordJob::finished, this,
+    //            [](QKeychain::Job *job) {
+    //                if (job->error()) {
+    //                    qWarning() << job->errorString();
+    //                }
+    //                job->deleteLater();
+    //            });
+    //    job->start();
+}
+
+void cavoke::auth::AuthenticationManager::relogin() {
+    deleteSecurePassword(refresh_token_profile);
+    oauth2.setRefreshToken("");
+    // Immediately asks user to relogin
+    // Terrible solution, couldn't find anything better
+    // At least he can decline, so fine....
+    oauth2.grant();
+}
+
+const QString cavoke::auth::AuthenticationManager::authorizationUrl =
+    "https://cavoke.eu.auth0.com/authorize";
+const QString cavoke::auth::AuthenticationManager::accessTokenUrl =
+    "https://cavoke.eu.auth0.com/oauth/token";
+const QString cavoke::auth::AuthenticationManager::logoutUrl =
+    "https://cavoke.eu.auth0.com/v2/logout";
+const QString cavoke::auth::AuthenticationManager::clientId =
+    "yxkEiSikGF6JSaFwIikeLQlUNAUUR0ak";
+const QString cavoke::auth::AuthenticationManager::scope =
+    "identity sessions profile users offline_access";
+const QString cavoke::auth::AuthenticationManager::audience =
+    "https://develop.api.cavoke.wlko.me";  // NOTE: should not equal to HOST, as
+                                           // this must be registered as API
+                                           // endpoint. Basically don't change
+                                           // this.
+const QString cavoke::auth::AuthenticationManager::refresh_token_profile =
+    "cavoke_profiles_refresh";
\ No newline at end of file
diff --git a/client/AuthenticationManager.h b/client/AuthenticationManager.h
new file mode 100644
index 00000000..558cb48d
--- /dev/null
+++ b/client/AuthenticationManager.h
@@ -0,0 +1,45 @@
+#ifndef CAVOKE_AUTHENTICATIONMANAGER_H
+#define CAVOKE_AUTHENTICATIONMANAGER_H
+
+#include <QOAuth2AuthorizationCodeFlow>
+#include <QSettings>
+
+namespace cavoke::auth {
+/// Manages all Oauth2 related things. Including code flow itself and storing
+/// refresh tokens.
+struct AuthenticationManager : public QObject {
+    Q_OBJECT
+public:
+    AuthenticationManager() = default;
+    QOAuth2AuthorizationCodeFlow oauth2;
+    /// Singleton wrapper
+    static AuthenticationManager &getInstance() {
+        static AuthenticationManager obj;
+        return obj;
+    }
+    bool checkAuthStatus();
+    void init();
+    void relogin();
+signals:
+    void authenticated();
+
+private:
+    void writeSecurePassword(const QString &profile, const QString &pass);
+    template <typename L>
+    void readSecurePassword(const QString &profile, L callback);
+    void deleteSecurePassword(const QString &profile);
+
+    QSettings settings{this};  // FIXME: move to qtkeychain
+
+    const static QString authorizationUrl;
+    const static QString accessTokenUrl;
+    const static QString logoutUrl;
+    const static QString clientId;
+    const static QString scope;
+    const static QString audience;
+
+    const static QString refresh_token_profile;
+};
+}  // namespace cavoke::auth
+
+#endif  // CAVOKE_AUTHENTICATIONMANAGER_H
diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt
index 69b3749d..0bec39f4 100644
--- a/client/CMakeLists.txt
+++ b/client/CMakeLists.txt
@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.10)
+cmake_minimum_required(VERSION 3.16)
 project(cavoke_client)
 
 set(QT_MAJOR_VERSION 6 CACHE STRING "Qt Major Version (e.g. Qt5/Qt6)")
@@ -6,9 +6,18 @@ set(QT_MAJOR_VERSION 6 CACHE STRING "Qt Major Version (e.g. Qt5/Qt6)")
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
-find_package(Qt${QT_MAJOR_VERSION}Widgets REQUIRED)
-find_package(Qt${QT_MAJOR_VERSION}Quick REQUIRED)
-find_package(Qt${QT_MAJOR_VERSION}Network REQUIRED)
+find_package(ECM 5.90.0 REQUIRED CONFIG)
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} )
+
+include(FeatureSummary)
+include(ECMAddAppIcon)
+include(ECMQtDeclareLoggingCategory)
+include(ECMInstallIcons)
+include(ECMSetupVersion)
+include(KDEInstallDirs)
+include(KDECMakeSettings)
+
+find_package(Qt${QT_MAJOR_VERSION} REQUIRED COMPONENTS Widgets Quick Network NetworkAuth)
 
 set(CMAKE_AUTOMOC ON)
 set(CMAKE_AUTOUIC ON)
@@ -17,32 +26,49 @@ set(CMAKE_AUTORCC ON)
 include_directories(${CMAKE_BINARY_DIR}
         controllers
         models
-        views)
+        views
+        #        ../third_party/qtkeychain
+        )
 
 # https://api.kde.org/frameworks-api/frameworks-apidocs/frameworks/karchive/html/index.html
 find_package(KF5Archive REQUIRED)
 
 #add_compile_definitions(MOCK)
+add_compile_definitions(REAL)
+
+aux_source_directory(views VIEWS_DIR)
+aux_source_directory(entities ENTITIES_DIR)
 
 add_executable(cavoke_client
         main.cpp
         controllers/cavokeclientcontroller.cpp
         models/cavokeclientmodel.cpp
         models/cavokeqmlgamemodel.cpp
-        views/testwindowview.cpp
-        views/startview.cpp
-        views/joingameview.cpp
-        views/creategameview.cpp
-        views/settingsview.cpp
-        views/gameslistview.cpp
-        views/protoroomview.cpp
+        ${VIEWS_DIR}
+        ${ENTITIES_DIR}
         cache_manager.cpp
         network_manager.cpp
-        gameinfo.cpp
-        sessioninfo.cpp
-        )
+        resources/resources.qrc
+        AuthenticationManager.cpp)
+
+target_link_libraries(cavoke_client PRIVATE Qt${QT_MAJOR_VERSION}::Widgets)
+target_link_libraries(cavoke_client PRIVATE Qt${QT_MAJOR_VERSION}::Quick)
+target_link_libraries(cavoke_client PRIVATE Qt${QT_MAJOR_VERSION}::Network)
+target_link_libraries(cavoke_client PRIVATE Qt${QT_MAJOR_VERSION}::NetworkAuth)
+target_link_libraries(cavoke_client PRIVATE KF5::Archive)
+
+install(TARGETS ${PROJECT_NAME} ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
+configure_file(${CMAKE_SOURCE_DIR}/client/cavoke.desktop
+        ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.desktop)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.desktop DESTINATION ${KDE_INSTALL_APPDIR} )
+file(GLOB_RECURSE ICON_FILES "${CMAKE_CURRENT_SOURCE_DIR}/resources/packaging/*-apps-cavoke.png")
+
+# Add icon files to the application's source files to have CMake bundle them in the executable.
+ecm_add_app_icon(ICONS_SOURCES ICONS ${ICON_FILES})
+target_sources(${PROJECT_NAME} PRIVATE ${ICONS_SOURCES})
 
-target_link_libraries(cavoke_client Qt${QT_MAJOR_VERSION}::Widgets)
-target_link_libraries(cavoke_client Qt${QT_MAJOR_VERSION}::Quick)
-target_link_libraries(cavoke_client Qt${QT_MAJOR_VERSION}::Network)
-target_link_libraries(cavoke_client KF5::Archive)
+ecm_install_icons(
+        ICONS ${ICON_FILES}
+        DESTINATION ${KDE_INSTALL_ICONDIR}
+        THEME hicolor
+)
diff --git a/client/cavoke.desktop b/client/cavoke.desktop
new file mode 100644
index 00000000..e0d87da6
--- /dev/null
+++ b/client/cavoke.desktop
@@ -0,0 +1,11 @@
+[Desktop Entry]
+Categories=Game;
+Type=Application
+Exec=cavoke_client
+Name=Cavoke Client
+Comment=An online board games platform
+Icon=cavoke
+GenericName=Online board games platform
+Keywords=cavoke;games;
+Terminal=false
+StartupWMClass=cavoke_client
diff --git a/client/controllers/cavokeclientcontroller.cpp b/client/controllers/cavokeclientcontroller.cpp
index 1195c25f..75578b25 100644
--- a/client/controllers/cavokeclientcontroller.cpp
+++ b/client/controllers/cavokeclientcontroller.cpp
@@ -1,4 +1,5 @@
 #include "cavokeclientcontroller.h"
+#include <QOAuthHttpServerReplyHandler>
 
 CavokeClientController::CavokeClientController(QObject *parent)
     : QObject{parent},
@@ -7,8 +8,11 @@ CavokeClientController::CavokeClientController(QObject *parent)
       testWindowView{},
       startView{},
       joinGameView{},
+      statisticsView{},
       settingsView{},
-      protoRoomView{} {
+      roomView{},
+      sessionView{},
+      settings{} {
     // startQml connection
     connect(&model, SIGNAL(startQmlApplication(CavokeQmlGameModel *)), this,
             SLOT(startQmlApplication(CavokeQmlGameModel *)));
@@ -24,12 +28,13 @@ CavokeClientController::CavokeClientController(QObject *parent)
             SLOT(showStartView()));
     connect(&settingsView, SIGNAL(shownStartView()), this,
             SLOT(showStartView()));
-    connect(&protoRoomView, SIGNAL(shownStartView()), this,
+    connect(&statisticsView, SIGNAL(shownStartView()), this,
             SLOT(showStartView()));
+    connect(&roomView, SIGNAL(shownStartView()), this, SLOT(showStartView()));
 
     // Main navigation buttons from startView
     connect(&startView, SIGNAL(shownTestWindowView()), this,
-            SLOT(showTestWindowView()));
+            SLOT(showTestWindowView()));  // Not displayed
     connect(&startView, SIGNAL(shownJoinGameView()), this,
             SLOT(showJoinGameView()));
     connect(&startView, SIGNAL(shownCreateGameView()), this,
@@ -38,6 +43,8 @@ CavokeClientController::CavokeClientController(QObject *parent)
             SLOT(showGamesListView()));
     connect(&startView, SIGNAL(shownSettingsView()), this,
             SLOT(showSettingsView()));
+    connect(&startView, SIGNAL(shownStatisticsView()), this,
+            SLOT(showStatisticsView()));
 
     // startView Exit button
     connect(&startView, SIGNAL(clickedExitButton()), this,
@@ -50,43 +57,47 @@ CavokeClientController::CavokeClientController(QObject *parent)
             &networkManager, SLOT(getHealth()));
 
     // createGameView actions
-    connect(&createGameView, SIGNAL(currentIndexChanged(int)), &model,
-            SLOT(receivedGameIndexChange(int)));
-    connect(&model, SIGNAL(updateSelectedGame(GameInfo)), &createGameView,
-            SLOT(gotNewSelectedGame(GameInfo)));
-
-    connect(&createGameView, SIGNAL(startedCreateGameRoutine(int)), this,
-            SLOT(createGameStart(int)));
-    connect(this, SIGNAL(createGameDownloaded()), this,
-            SLOT(createGameSendRequest()));
-
-    // both Join and Create gameView actions
-    connect(&networkManager, SIGNAL(gotSessionInfo(SessionInfo)), this,
-            SLOT(gotSessionInfo(SessionInfo)));
+    connect(&createGameView, SIGNAL(startedCreateGameRoutine(QString)), this,
+            SLOT(createGameStart(QString)));
 
-    // joinGameView workflow
+    // joinGameView actions
     connect(&joinGameView, SIGNAL(joinedGame(QString)), this,
             SLOT(joinGameStart(QString)));
-    connect(this, SIGNAL(joinGameDownloaded()), this,
-            SLOT(creatingJoiningGameDone()));
 
     // gamesListView actions
     connect(&gamesListView, SIGNAL(currentIndexChanged(int)), &model,
             SLOT(receivedGameIndexChangeInList(int)));
+    connect(&gamesListView, SIGNAL(requestGameStatistics(QString)),
+            &networkManager, SLOT(getGameStatistics(QString)));
     connect(&model, SIGNAL(updateSelectedGameInList(GameInfo)), &gamesListView,
             SLOT(gotNewSelectedGame(GameInfo)));
+    connect(&networkManager, SIGNAL(gotGameStatistics(GameStatistics)),
+            &gamesListView, SLOT(gotNewGameStatistics(GameStatistics)));
     connect(&gamesListView, SIGNAL(requestedDownloadGame(int)), &model,
             SLOT(gotIndexToDownload(int)));
+    connect(this, SIGNAL(clearScreens()), &gamesListView, SLOT(displayEmpty()));
+
+    // session/room/game-Info processing actions
+    connect(&networkManager, SIGNAL(gotSessionInfo(SessionInfo)), this,
+            SLOT(gotSessionInfo(SessionInfo)));
+    connect(&networkManager, SIGNAL(gotGameInfo(GameInfo)), this,
+            SLOT(gotCurrentGameInfo(GameInfo)));
+    connect(this, SIGNAL(setGameName(QString)), &sessionView,
+            SLOT(updateGameName(QString)));
+    connect(&networkManager, SIGNAL(gotRoomInfo(RoomInfo)), this,
+            SLOT(gotRoomInfo(RoomInfo)));
 
     // Download games list from server workflow
     connect(this, SIGNAL(loadGamesList()), &networkManager,
             SLOT(getGamesList()));
     connect(&networkManager, SIGNAL(finalizedGamesList(QJsonArray)), &model,
             SLOT(updateGamesList(QJsonArray)));
-    connect(&model, SIGNAL(gamesListUpdated(std::vector<GameInfo>)),
-            &createGameView, SLOT(gotGamesListUpdate(std::vector<GameInfo>)));
     connect(&model, SIGNAL(gamesListUpdated(std::vector<GameInfo>)),
             &gamesListView, SLOT(gotGamesListUpdate(std::vector<GameInfo>)));
+    connect(&model, SIGNAL(gamesListUpdated(std::vector<GameInfo>)),
+            &statisticsView, SLOT(gotGamesListUpdate(std::vector<GameInfo>)));
+    connect(&model, SIGNAL(gamesListUpdated(std::vector<GameInfo>)), &roomView,
+            SLOT(gotGamesListUpdate(std::vector<GameInfo>)));
 
     // Download and unpack game workflow
     connect(&model, SIGNAL(downloadGame(QString)), &networkManager,
@@ -94,19 +105,107 @@ CavokeClientController::CavokeClientController(QObject *parent)
     connect(&networkManager, SIGNAL(downloadedGameFile(QFile *, QString)), this,
             SLOT(unpackDownloadedQml(QFile *, QString)));
 
-    // protoRoomView actions
-    connect(&protoRoomView, SIGNAL(joinedCreatedGame(QString)), this,
-            SLOT(startQmlByGameId(QString)));
+    // roomView actions
+    connect(&roomView, SIGNAL(leftRoom()), this, SLOT(leftRoom()));
+    connect(&roomView, SIGNAL(createdSession(QString)), this,
+            SLOT(createSessionStart(QString)));
+    connect(&roomView, SIGNAL(joinedSession(QString)), this,
+            SLOT(joinSessionStart(QString)));
+    connect(&roomView, SIGNAL(requestedSessionUpdate(QString)), &networkManager,
+            SLOT(getSessionInfo(QString)));
+
+    // sessionView actions
+    connect(&sessionView, SIGNAL(joinedCreatedGame()), this,
+            SLOT(startLoadedQml()));
+    connect(&networkManager, SIGNAL(gotValidationResult(ValidationResult)),
+            &sessionView, SLOT(updateValidationResult(ValidationResult)));
+    connect(&sessionView, SIGNAL(createdGame()), &networkManager,
+            SLOT(startSession()));
+    connect(this, SIGNAL(createdAvailableRolesList(std::vector<Role>)),
+            &sessionView, SLOT(gotRolesListUpdate(std::vector<Role>)));
+    connect(&sessionView, SIGNAL(newRoleChosen(int)), &networkManager,
+            SLOT(changeRoleInSession(int)));
+    connect(&sessionView, SIGNAL(leftSession()), this, SLOT(leftSession()));
+    connect(&sessionView, SIGNAL(shownRoomView()), this, SLOT(showRoomView()));
+
+    // settingsView actions
+    connect(this, SIGNAL(initSettingsValues(QString, QString)), &settingsView,
+            SLOT(initStartValues(QString, QString)));
+    connect(&settingsView, SIGNAL(updatedSettings(QString, QString)), this,
+            SLOT(updateSettings(QString, QString)));
+    connect(&networkManager, SIGNAL(gotDisplayName(QString)), &settingsView,
+            SLOT(updateDisplayName(QString)));
+
+    // statisticsView actions
+    connect(&networkManager, SIGNAL(gotUserStatistics(UserStatistics)),
+            &statisticsView, SLOT(gotUserStatisticsUpdate(UserStatistics)));
+    connect(&statisticsView, SIGNAL(requestedRefresh()), &networkManager,
+            SLOT(getMyUserStatistics()));
+    connect(&networkManager, SIGNAL(gotUserGameStatistics(UserGameStatistics)),
+            &statisticsView,
+            SLOT(gotUserGameStatisticsUpdate(UserGameStatistics)));
+    connect(&statisticsView, SIGNAL(statisticsGameChanged(QString)),
+            &networkManager, SLOT(getMyUserGameStatistics(QString)));
+
+    defaultSettingsInitialization();
+
+    // oauth reply handler
+    auto replyHandler = new QOAuthHttpServerReplyHandler(1337, this);
+    auto &auth = cavoke::auth::AuthenticationManager::getInstance();
+    auth.oauth2.setReplyHandler(replyHandler);
+
+    // on new authentication update my user id and display name
+    connect(&auth, SIGNAL(authenticated()), &networkManager, SLOT(getMe()));
+    connect(&auth, SIGNAL(authenticated()), &networkManager,
+            SLOT(getMyUserStatistics()));
+    // initialize auth in a separate thread
+    QTimer::singleShot(0, [&]() { auth.init(); });
+
+    showStartView();
+}
 
-    startView.show();
+void CavokeClientController::defaultSettingsInitialization() {
+    settings.setValue(PLAYER_NICKNAME,
+                      settings.value(PLAYER_NICKNAME, DEFAULT_NICKNAME));
+    settings.setValue(
+        NETWORK_HOST,
+        settings.value(NETWORK_HOST, NetworkManager::DEFAULT_HOST));
+
+    networkManager.changeHost(
+        QUrl::fromUserInput(settings.value(NETWORK_HOST).toString()));
+
+    if (cavoke::auth::AuthenticationManager::getInstance().checkAuthStatus()) {
+        networkManager.getMe();
+    }
 
-    emit loadGamesList();
+    emit initSettingsValues(settings.value(PLAYER_NICKNAME).toString(),
+                            settings.value(NETWORK_HOST).toString());
 }
 
 void CavokeClientController::showTestWindowView() {
     testWindowView.show();
 }
 
+void CavokeClientController::leftSession(bool real_leave) {
+    if (real_leave) {
+        networkManager.leaveSession();
+    }
+    networkManager.stopGamePolling();
+    networkManager.stopSessionPolling();
+    networkManager.stopValidationPolling();
+    qmlDownloadStatus = QMLDownloadStatus::NOT_STARTED;
+    hostGuestStatus = HostGuestStatus::NOT_IN;
+    currentGameInfo = GameInfo();
+    currentSessionInfo = SessionInfo();
+}
+
+void CavokeClientController::leftRoom() {
+    networkManager.stopRoomPolling();
+    networkManager.leaveRoom();
+    roomHostGuestStatus = HostGuestStatus::NOT_IN;
+    currentRoomInfo = RoomInfo();
+}
+
 void CavokeClientController::showStartView() {
     startView.show();
 }
@@ -123,6 +222,21 @@ void CavokeClientController::showCreateGameView() {
     createGameView.show();
 }
 
+void CavokeClientController::showRoomView() {
+    displacement = UserDisplacement::ROOM;
+    roomView.show();
+}
+
+void CavokeClientController::showSessionView() {
+    displacement = UserDisplacement::SESSION;
+    sessionView.show();
+}
+
+void CavokeClientController::showStatisticsView() {
+    statisticsView.requestUpdates();
+    statisticsView.show();
+}
+
 void CavokeClientController::showSettingsView() {
     settingsView.show();
 }
@@ -152,6 +266,8 @@ void CavokeClientController::exitApplication() {
     joinGameView.close();
     gamesListView.close();
     createGameView.close();
+    roomView.close();
+    sessionView.close();
     settingsView.close();
     startView.close();
 }
@@ -165,13 +281,23 @@ void CavokeClientController::startQmlByGameId(const QString &gameId) {
     connect(&networkManager, SIGNAL(gotGameUpdate(QString)),
             currentQmlGameModel, SLOT(getUpdateFromNetwork(QString)));
     connect(currentQmlGameModel, SIGNAL(closingQml()), this, SLOT(stopQml()));
-    networkManager.startPolling();
+    networkManager.startGamePolling();
+}
+
+void CavokeClientController::startLoadedQml() {
+    displacement = UserDisplacement::GAME;
+    networkManager.stopSessionPolling();
+    networkManager.stopValidationPolling();
+    networkManager.stopRoomPolling();
+    startQmlByGameId(currentGameInfo.id);
 }
 
 void CavokeClientController::stopQml() {
-    startView.show();
+    networkManager.stopGamePolling();
+    networkManager.startRoomPolling();
+    leftSession(false);  // Without actual `leave` request, due to issue #171
+    showRoomView();
     currentQmlGameModel->deleteLater();
-    networkManager.stopPolling();
 }
 
 void CavokeClientController::unpackDownloadedQml(QFile *file,
@@ -179,72 +305,161 @@ void CavokeClientController::unpackDownloadedQml(QFile *file,
     cache_manager::save_zip_to_cache(file, gameId);
     qDebug() << "UnpackDownloadedQml Finished";
     file->deleteLater();
-    if (status == CreateJoinControllerStatus::CREATING) {
-        emit createGameDownloaded();
-    } else if (status == CreateJoinControllerStatus::JOINING) {
-        emit joinGameDownloaded();
-    }
-}
 
-void CavokeClientController::createGameStart(int gameIndex) {
-    qDebug() << "Now we are creating game with index: " << gameIndex;
-
-    status = CreateJoinControllerStatus::CREATING;
-    protoRoomView.prepareJoinCreate(false);
+    qmlDownloadStatus = QMLDownloadStatus::DOWNLOADED;
+}
 
-    currentGameId = model.getGameIdByIndex(gameIndex);
+void CavokeClientController::createGameStart(const QString &roomName) {
+    qDebug() << "Now we are creating room with name:" << roomName;
 
     createGameView.close();
-    protoRoomView.show();
-
-    downloadCurrentGame();
+    showRoomView();
+    networkManager.createRoom(roomName);
 }
 
 void CavokeClientController::joinGameStart(const QString &inviteCode) {
-    qDebug() << "Now we are joinGameStart with inviteCode: " << inviteCode;
-
-    status = CreateJoinControllerStatus::JOINING;
-    protoRoomView.prepareJoinCreate(true);
-
-    protoRoomView.updateStatus(ProtoRoomView::CreatingGameStatus::REQUESTED);
+    qDebug() << "Now we are joining room with inviteCode:" << inviteCode;
 
     joinGameView.close();
-    protoRoomView.show();
+    showRoomView();
+    networkManager.joinRoom(inviteCode);
+}
 
-    networkManager.joinSession(inviteCode);
+void CavokeClientController::createSessionStart(const QString &gameId) {
+    qDebug() << "Now we are creating session with gameId:" << gameId;
+
+    roomView.close();
+    showSessionView();
+    networkManager.roomCreateSession(gameId);
 }
 
-void CavokeClientController::downloadCurrentGame() {
-    qDebug() << "Now we are downloading game: " << currentGameId;
+void CavokeClientController::joinSessionStart(const QString &sessionId) {
+    qDebug() << "Now we are joining session with sessionId:" << sessionId;
 
-    protoRoomView.updateStatus(ProtoRoomView::CreatingGameStatus::DOWNLOAD);
-    protoRoomView.updateGameName(currentGameId);
-    model.gotGameIdToDownload(currentGameId);
+    roomView.close();
+    showSessionView();
+    networkManager.joinSession(sessionId);
 }
 
-void CavokeClientController::createGameSendRequest() {
-    qDebug() << "Now we are createGameSendRequest with id: " << currentGameId;
+void CavokeClientController::gotRoomInfo(const RoomInfo &roomInfo) {
+    qDebug() << "Got room info";
+
+    if (displacement != UserDisplacement::ROOM) {
+        return;  // We are not in a room, actually
+    }
 
-    networkManager.createSession(currentGameId);
-    protoRoomView.updateStatus(ProtoRoomView::CreatingGameStatus::REQUESTED);
+    currentRoomInfo = roomInfo;
+
+    if (roomHostGuestStatus == HostGuestStatus::NOT_IN) {
+        networkManager.startRoomPolling();
+    }
+
+    if (currentRoomInfo.isHost &&
+        roomHostGuestStatus != HostGuestStatus::HOST) {
+        becomeRoomHost();
+    } else if (!currentRoomInfo.isHost &&
+               roomHostGuestStatus != HostGuestStatus::GUEST) {
+        becomeRoomGuest();
+    }
+
+    roomView.updateRoomInfo(currentRoomInfo);
 }
 
 void CavokeClientController::gotSessionInfo(const SessionInfo &sessionInfo) {
     qDebug() << "Now we got session info";
 
-    protoRoomView.updateInviteCode(sessionInfo.invite_code);
+    if (displacement == UserDisplacement::ROOM) {
+        roomView.updateSessionInfo(sessionInfo);
+        return;
+    }
+
+    if (displacement != UserDisplacement::SESSION) {
+        return;  // We are not in a session, actually
+    }
+
+    currentSessionInfo = sessionInfo;
+
+    if (hostGuestStatus == HostGuestStatus::NOT_IN) {
+        networkManager.startSessionPolling();
+    }
+
+    if (currentSessionInfo.isHost && hostGuestStatus != HostGuestStatus::HOST) {
+        becomeHost();
+    } else if (!currentSessionInfo.isHost &&
+               hostGuestStatus != HostGuestStatus::GUEST) {
+        becomeGuest();
+    }
+
+    if (qmlDownloadStatus == QMLDownloadStatus::NOT_STARTED) {
+        networkManager.getGamesClient(currentSessionInfo.game_id);
+        qmlDownloadStatus = QMLDownloadStatus::DOWNLOADING;
+        sessionView.updateStatus(SessionView::CreatingGameStatus::DOWNLOAD);
+    }
+
+    sessionView.updateSessionInfo(currentSessionInfo);
+
+    if (currentGameInfo.players_num == 0) {
+        networkManager.getGamesConfig(currentSessionInfo.game_id);
+    } else if (qmlDownloadStatus == QMLDownloadStatus::DOWNLOADED) {
+        sessionView.updateStatus(SessionView::CreatingGameStatus::DONE);
+        collectListOfAvailableRoles();
+    }
+}
 
-    if (status == CreateJoinControllerStatus::CREATING) {
-        creatingJoiningGameDone();
-    } else if (status == CreateJoinControllerStatus::JOINING) {
-        currentGameId = sessionInfo.game_id;
-        protoRoomView.updateGameName(currentGameId);
-        downloadCurrentGame();
+void CavokeClientController::gotCurrentGameInfo(const GameInfo &gameInfo) {
+    currentGameInfo = gameInfo;
+    emit setGameName(currentGameInfo.display_name);
+}
+
+void CavokeClientController::updateSettings(const QString &displayName,
+                                            const QString &host) {
+    settings.setValue(PLAYER_NICKNAME, displayName);
+    settings.setValue(NETWORK_HOST, host);
+    emit clearScreens();
+    networkManager.changeHost(QUrl::fromUserInput(host));
+    networkManager.changeName(displayName);
+}
+void CavokeClientController::collectListOfAvailableRoles() {
+    std::vector<bool> isFree(currentGameInfo.players_num, true);
+    int ourRole = -1;
+    QString userId = networkManager.getUserId();
+    for (const auto &player : currentSessionInfo.players) {
+        isFree[player.player_id] = false;
+        if (player.user.user_id == userId) {
+            ourRole = player.player_id;
+        }
     }
+    if (ourRole == -1) {
+        return;
+        // I guess it is the bug when we have already left the session but
+        //            still
+        // somehow made a request to get info about session
+    }
+    std::vector<Role> availableRoles;
+    availableRoles.emplace_back(currentGameInfo.role_names[ourRole],
+                                ourRole);  // Now first.
+    for (int i = 0; i < currentGameInfo.players_num; ++i) {
+        if (isFree[i]) {
+            availableRoles.emplace_back(currentGameInfo.role_names[i], i);
+        }
+    }
+    emit createdAvailableRolesList(availableRoles);
 }
 
-void CavokeClientController::creatingJoiningGameDone() {
-    qDebug() << "Now creating/joining game preparations are done";
+void CavokeClientController::becomeHost() {
+    hostGuestStatus = HostGuestStatus::HOST;
+    networkManager.startValidationPolling();
+}
+
+void CavokeClientController::becomeGuest() {
+    hostGuestStatus = HostGuestStatus::GUEST;
+    networkManager.stopValidationPolling();
+}
+
+void CavokeClientController::becomeRoomHost() {
+    roomHostGuestStatus = HostGuestStatus::HOST;
+}
 
-    protoRoomView.updateStatus(ProtoRoomView::CreatingGameStatus::DONE);
+void CavokeClientController::becomeRoomGuest() {
+    roomHostGuestStatus = HostGuestStatus::GUEST;
 }
diff --git a/client/controllers/cavokeclientcontroller.h b/client/controllers/cavokeclientcontroller.h
index bbc67996..65caedb6 100644
--- a/client/controllers/cavokeclientcontroller.h
+++ b/client/controllers/cavokeclientcontroller.h
@@ -1,21 +1,25 @@
 #ifndef CAVOKECLIENTCONTROLLER_H
 #define CAVOKECLIENTCONTROLLER_H
 
-#include <cache_manager.h>
-#include <views/gameslistview.h>
 #include <QObject>
 #include <QtQuick>
+#include "cache_manager.h"
 #include "cavokeclientmodel.h"
-#include "creategameview.h"
-#include "joingameview.h"
 #include "network_manager.h"
-#include "protoroomview.h"
-#include "settingsview.h"
-#include "startview.h"
-#include "testwindowview.h"
+#include "views/creategameview.h"
+#include "views/gameslistview.h"
+#include "views/joingameview.h"
+#include "views/roomview.h"
+#include "views/sessionview.h"
+#include "views/settingsview.h"
+#include "views/startview.h"
+#include "views/statisticsview.h"
+#include "views/testwindowview.h"
 
 class CavokeClientController : public QObject {
-    enum class CreateJoinControllerStatus { NOTHING, CREATING, JOINING };
+    enum class UserDisplacement { NOWHERE, ROOM, SESSION, GAME };
+    enum class QMLDownloadStatus { NOT_STARTED, DOWNLOADING, DOWNLOADED };
+    enum class HostGuestStatus { NOT_IN, HOST, GUEST };
     Q_OBJECT
 public:
     explicit CavokeClientController(QObject *parent = nullptr);
@@ -26,27 +30,46 @@ public slots:
     void showJoinGameView();
     void showGamesListView();
     void showCreateGameView();
+    void showStatisticsView();
     void showSettingsView();
+    void showRoomView();
+    void showSessionView();
+    void updateSettings(const QString &displayName, const QString &host);
 
 signals:
     void loadGamesList();
-    void createGameDownloaded();
-    void joinGameDownloaded();
+    void setGameName(const QString &gameName);
+    void initSettingsValues(const QString &nickname, const QString &host);
+    void clearScreens();
+    void createdAvailableRolesList(const std::vector<Role> &availableRoles);
 
 private slots:
     void startQmlApplication(CavokeQmlGameModel *);
     void exitApplication();
     void startQmlByGameId(const QString &gameId);
+    void startLoadedQml();
     void stopQml();
     void unpackDownloadedQml(QFile *file, const QString &gameId);
-    void createGameStart(int gameIndex);
+    void createGameStart(const QString &roomName);
     void joinGameStart(const QString &inviteCode);
-    void downloadCurrentGame();
-    void creatingJoiningGameDone();
-    void createGameSendRequest();
+    void createSessionStart(const QString &gameId);
+    void joinSessionStart(const QString &sessionId);
+    void gotCurrentGameInfo(const GameInfo &gameInfo);
+    void gotRoomInfo(const RoomInfo &roomInfo);
     void gotSessionInfo(const SessionInfo &sessionInfo);
+    void collectListOfAvailableRoles();
+    void becomeHost();
+    void becomeGuest();
+    void becomeRoomHost();
+    void becomeRoomGuest();
+    void leftSession(bool real_leave = true);
+    void leftRoom();
 
 private:
+    void defaultSettingsInitialization();
+    const static inline QString PLAYER_NICKNAME{"player/nickname"};
+    const static inline QString NETWORK_HOST{"network/host"};
+    const static inline QString DEFAULT_NICKNAME{"Guest"};
     NetworkManager networkManager;
     CavokeClientModel model;
     TestWindowView testWindowView;
@@ -54,11 +77,19 @@ private slots:
     JoinGameView joinGameView;
     CreateGameView createGameView;
     GamesListView gamesListView;
+    StatisticsView statisticsView;
     SettingsView settingsView;
-    ProtoRoomView protoRoomView;
+    RoomView roomView;
+    SessionView sessionView;
     CavokeQmlGameModel *currentQmlGameModel = nullptr;
-    CreateJoinControllerStatus status;
-    QString currentGameId;
+    RoomInfo currentRoomInfo;
+    SessionInfo currentSessionInfo;
+    GameInfo currentGameInfo;
+    UserDisplacement displacement = UserDisplacement::NOWHERE;
+    QMLDownloadStatus qmlDownloadStatus = QMLDownloadStatus::NOT_STARTED;
+    HostGuestStatus hostGuestStatus = HostGuestStatus::NOT_IN;
+    HostGuestStatus roomHostGuestStatus = HostGuestStatus::NOT_IN;
+    QSettings settings;
 };
 
 #endif  // CAVOKECLIENTCONTROLLER_H
diff --git a/client/entities/gameinfo.cpp b/client/entities/gameinfo.cpp
new file mode 100644
index 00000000..7c109551
--- /dev/null
+++ b/client/entities/gameinfo.cpp
@@ -0,0 +1,41 @@
+#include "gameinfo.h"
+#include <utility>
+GameInfo::GameInfo() = default;
+GameInfo::GameInfo(QString _id,
+                   QString _display_name,
+                   QString _description,
+                   int _players_num,
+                   QVector<QString> _role_names)
+    : id(std::move(_id)),
+      display_name(std::move(_display_name)),
+      description(std::move(_description)),
+      players_num(_players_num),
+      role_names(std::move(_role_names)) {
+}
+void GameInfo::read(const QJsonObject &json) {
+    if (json.contains(ID) && json[ID].isString())
+        id = json[ID].toString();
+
+    if (json.contains(DISPLAY_NAME) && json[DISPLAY_NAME].isString())
+        display_name = json[DISPLAY_NAME].toString();
+
+    if (json.contains(DESCRIPTION) && json[DESCRIPTION].isString())
+        description = json[DESCRIPTION].toString();
+
+    if (json.contains(PLAYERS_NUM) && json[PLAYERS_NUM].isDouble())
+        players_num = json[PLAYERS_NUM].toInt();
+
+    if (json.contains(ROLE_NAMES) && json[ROLE_NAMES].isArray()) {
+        auto objects = json[ROLE_NAMES].toArray();
+        std::transform(objects.begin(), objects.end(),
+                       std::back_inserter(role_names),
+                       [](const QJsonValueRef &obj) { return obj.toString(); });
+    }
+}
+void GameInfo::write(QJsonObject &json) const {
+    json[ID] = id;
+    json[DISPLAY_NAME] = display_name;
+    json[DESCRIPTION] = description;
+    json[PLAYERS_NUM] = players_num;
+    // Actually, write is not used
+}
diff --git a/client/gameinfo.h b/client/entities/gameinfo.h
similarity index 52%
rename from client/gameinfo.h
rename to client/entities/gameinfo.h
index e5c577d3..b42758f8 100644
--- a/client/gameinfo.h
+++ b/client/entities/gameinfo.h
@@ -1,6 +1,7 @@
 #ifndef CAVOKE_CLIENT_GAMEINFO_H
 #define CAVOKE_CLIENT_GAMEINFO_H
 
+#include <QtCore/QJsonArray>
 #include <QtCore/QJsonObject>
 #include <QtCore/QString>
 struct GameInfo {
@@ -9,7 +10,8 @@ struct GameInfo {
     GameInfo(QString _id,
              QString _display_name,
              QString _description,
-             int _players_num);
+             int _players_num,
+             QVector<QString> _role_names);
 
     void read(const QJsonObject &json);
     void write(QJsonObject &json) const;
@@ -18,6 +20,14 @@ struct GameInfo {
     QString display_name;
     QString description;
     int players_num = 0;
+    QVector<QString> role_names;
+
+private:
+    static inline const QString ID = "id";
+    static inline const QString DISPLAY_NAME = "display_name";
+    static inline const QString DESCRIPTION = "description";
+    static inline const QString PLAYERS_NUM = "players_num";
+    static inline const QString ROLE_NAMES = "role_names";
 };
 
 #endif  // CAVOKE_CLIENT_GAMEINFO_H
diff --git a/client/entities/gamestatistics.cpp b/client/entities/gamestatistics.cpp
new file mode 100644
index 00000000..84072ac3
--- /dev/null
+++ b/client/entities/gamestatistics.cpp
@@ -0,0 +1,36 @@
+#include "gamestatistics.h"
+
+GameStatistics::GameStatistics() = default;
+
+GameStatistics::GameStatistics(int _average_duration_sec,
+                               int _average_players_count,
+                               int _total_time_played_sec,
+                               int _total_games_played)
+    : average_duration_sec(_average_duration_sec),
+      average_players_count(_average_players_count),
+      total_time_played_sec(_total_time_played_sec),
+      total_games_played(_total_games_played) {
+}
+
+void GameStatistics::read(const QJsonObject &json) {
+    if (json.contains(AVERAGE_DURATION_SEC) &&
+        json[AVERAGE_DURATION_SEC].isDouble()) {
+        average_duration_sec = json[AVERAGE_DURATION_SEC].toInt();
+    }
+    if (json.contains(AVERAGE_PLAYERS_COUNT) &&
+        json[AVERAGE_PLAYERS_COUNT].isDouble()) {
+        average_players_count = json[AVERAGE_PLAYERS_COUNT].toInt();
+    }
+    if (json.contains(TOTAL_TIME_PLAYED_SEC) &&
+        json[TOTAL_TIME_PLAYED_SEC].isDouble()) {
+        total_time_played_sec = json[TOTAL_TIME_PLAYED_SEC].toInt();
+    }
+    if (json.contains(TOTAL_GAMES_PLAYED) &&
+        json[TOTAL_GAMES_PLAYED].isDouble()) {
+        total_games_played = json[TOTAL_GAMES_PLAYED].toInt();
+    }
+}
+
+void GameStatistics::write(QJsonObject &json) {
+    assert(false);  // Should not be used
+}
diff --git a/client/entities/gamestatistics.h b/client/entities/gamestatistics.h
new file mode 100644
index 00000000..36e4a3bc
--- /dev/null
+++ b/client/entities/gamestatistics.h
@@ -0,0 +1,29 @@
+#ifndef CAVOKE_GAMESTATISTICS_H
+#define CAVOKE_GAMESTATISTICS_H
+
+#include <QtCore/QJsonObject>
+#include <QtCore/QString>
+struct GameStatistics {
+public:
+    GameStatistics();
+    GameStatistics(int _average_duration_sec,
+                   int _average_players_count,
+                   int _total_time_played_sec,
+                   int _total_games_played);
+
+    void read(const QJsonObject &json);
+    static void write(QJsonObject &json);
+
+    int average_duration_sec = 0;
+    int average_players_count = 0;
+    int total_time_played_sec = 0;
+    int total_games_played = 0;
+
+private:
+    static inline const QString AVERAGE_DURATION_SEC = "average_duration_sec";
+    static inline const QString AVERAGE_PLAYERS_COUNT = "average_players_count";
+    static inline const QString TOTAL_TIME_PLAYED_SEC = "total_time_played_sec";
+    static inline const QString TOTAL_GAMES_PLAYED = "total_games_played";
+};
+
+#endif  // CAVOKE_USERSTATISTICS_H
diff --git a/client/entities/player.cpp b/client/entities/player.cpp
new file mode 100644
index 00000000..e29e354e
--- /dev/null
+++ b/client/entities/player.cpp
@@ -0,0 +1,22 @@
+#include "player.h"
+
+Player::Player() = default;
+
+Player::Player(int _player_id, User _user)
+    : player_id(_player_id), user(std::move(_user)) {
+}
+
+void Player::read(const QJsonObject &json) {
+    if (json.contains(PLAYER_ID) &&
+        json[PLAYER_ID].isDouble()) {  // FIXME: wat?
+        player_id = json[PLAYER_ID].toInt();
+    }
+    if (json.contains(USER) && json[USER].isObject()) {
+        user = User();
+        user.read(json[USER].toObject());
+    }
+}
+
+void Player::write(QJsonObject &json) {
+    assert(false);  // Should not be used
+}
diff --git a/client/entities/player.h b/client/entities/player.h
new file mode 100644
index 00000000..02f21b69
--- /dev/null
+++ b/client/entities/player.h
@@ -0,0 +1,23 @@
+#ifndef CAVOKE_PLAYER_H
+#define CAVOKE_PLAYER_H
+
+#include <QtCore/QJsonObject>
+#include <QtCore/QString>
+#include "user.h"
+struct Player {
+public:
+    Player();
+    Player(int _player_id, User _user);
+
+    void read(const QJsonObject &json);
+    static void write(QJsonObject &json);
+
+    int player_id{};
+    User user;
+
+private:
+    static inline const QString PLAYER_ID = "player_id";
+    static inline const QString USER = "user";
+};
+
+#endif  // CAVOKE_PLAYER_H
diff --git a/client/entities/role.cpp b/client/entities/role.cpp
new file mode 100644
index 00000000..0038f37a
--- /dev/null
+++ b/client/entities/role.cpp
@@ -0,0 +1,4 @@
+#include "role.h"
+
+Role::Role(QString _name, int _id) : name(std::move(_name)), id(_id) {
+}
diff --git a/client/entities/role.h b/client/entities/role.h
new file mode 100644
index 00000000..f669eb5e
--- /dev/null
+++ b/client/entities/role.h
@@ -0,0 +1,12 @@
+#ifndef CAVOKE_ROLE_H
+#define CAVOKE_ROLE_H
+
+#include <QString>
+struct Role {
+    QString name = "";
+    int id = 0;
+
+    Role(QString _name, int _id);
+};
+
+#endif  // CAVOKE_ROLE_H
diff --git a/client/entities/roominfo.cpp b/client/entities/roominfo.cpp
new file mode 100644
index 00000000..38c23c6a
--- /dev/null
+++ b/client/entities/roominfo.cpp
@@ -0,0 +1,54 @@
+#include "roominfo.h"
+#include <utility>
+RoomInfo::RoomInfo() = default;
+RoomInfo::RoomInfo(QString _room_id,
+                   QString _display_name,
+                   QString _invite_code,
+                   QString _session_id,
+                   QString _host_id,
+                   QVector<User> _members,
+                   SessionInfo _session)
+    : room_id(std::move(_room_id)),
+      display_name(std::move(_display_name)),
+      invite_code(std::move(_invite_code)),
+      session_id(std::move(_session_id)),
+      host_id(std::move(_host_id)),
+      members(std::move(_members)),
+      session(std::move(_session)) {
+}
+void RoomInfo::read(const QJsonObject &json) {
+    if (json.contains(ROOM_ID) && json[ROOM_ID].isString()) {
+        room_id = json[ROOM_ID].toString();
+    }
+
+    if (json.contains(DISPLAY_NAME) && json[DISPLAY_NAME].isString()) {
+        display_name = json[DISPLAY_NAME].toString();
+    }
+
+    if (json.contains(INVITE_CODE) && json[INVITE_CODE].isString()) {
+        invite_code = json[INVITE_CODE].toString();
+    }
+
+    if (json.contains(SESSION_ID) && json[SESSION_ID].isString()) {
+        session_id = json[SESSION_ID].toString();
+    }
+
+    if (json.contains(HOST_ID) && json[HOST_ID].isString()) {
+        host_id = json[HOST_ID].toString();
+    }
+
+    if (json.contains(MEMBERS) && json[MEMBERS].isArray()) {
+        for (auto obj : json[MEMBERS].toArray()) {
+            members.push_back(User());
+            members.back().read(obj.toObject());
+        }
+    }
+
+    if (json.contains(SESSION) && json[SESSION].isObject()) {
+        session.read(json[SESSION].toObject());
+        isSessionAlive = true;
+    }
+}
+void RoomInfo::write(QJsonObject &json) const {
+    assert(false);  // Should not be used
+}
diff --git a/client/entities/roominfo.h b/client/entities/roominfo.h
new file mode 100644
index 00000000..e1569a76
--- /dev/null
+++ b/client/entities/roominfo.h
@@ -0,0 +1,44 @@
+#ifndef CAVOKE_ROOMINFO_H
+#define CAVOKE_ROOMINFO_H
+
+#include <QtCore/QJsonArray>
+#include <QtCore/QJsonObject>
+#include <QtCore/QString>
+#include <QtCore/QVector>
+#include "sessioninfo.h"
+#include "user.h"
+struct RoomInfo {
+public:
+    RoomInfo();
+    RoomInfo(QString _room_id,
+             QString _display_name,
+             QString _invite_code,
+             QString _session_id,
+             QString _host_id,
+             QVector<User> _members,
+             SessionInfo _session);
+
+    void read(const QJsonObject &json);
+    void write(QJsonObject &json) const;
+
+    QString room_id;
+    QString display_name;
+    QString invite_code;
+    QString session_id;
+    QString host_id;
+    QVector<User> members;
+    SessionInfo session{};
+    bool isSessionAlive = false;
+    bool isHost = false;
+
+private:
+    static inline const QString ROOM_ID = "room_id";
+    static inline const QString DISPLAY_NAME = "display_name";
+    static inline const QString INVITE_CODE = "invite_code";
+    static inline const QString SESSION_ID = "session_id";
+    static inline const QString HOST_ID = "host_id";
+    static inline const QString MEMBERS = "members";
+    static inline const QString SESSION = "session";
+};
+
+#endif  // CAVOKE_ROOMINFO_H
diff --git a/client/entities/sessioninfo.cpp b/client/entities/sessioninfo.cpp
new file mode 100644
index 00000000..0567735c
--- /dev/null
+++ b/client/entities/sessioninfo.cpp
@@ -0,0 +1,51 @@
+#include "sessioninfo.h"
+#include <utility>
+SessionInfo::SessionInfo() = default;
+SessionInfo::SessionInfo(QString _session_id,
+                         QString _game_id,
+                         SessionInfo::Status _status,
+                         QString _host_id,
+                         QVector<Player> _players)
+    : session_id(std::move(_session_id)),
+      game_id(std::move(_game_id)),
+      status(_status),
+      host_id(std::move(_host_id)),
+      players(std::move(_players)) {
+}
+void SessionInfo::read(const QJsonObject &json) {
+    if (json.contains(SESSION_ID) && json[SESSION_ID].isString()) {
+        session_id = json[SESSION_ID].toString();
+    }
+
+    if (json.contains(GAME_ID) && json[GAME_ID].isString()) {
+        game_id = json[GAME_ID].toString();
+    }
+
+    if (json.contains(STATUS) && json[STATUS].isDouble()) {
+        switch (json[STATUS].toInt()) {
+            case 0:
+                status = Status::NOT_STARTED;
+                break;
+            case 1:
+                status = Status::RUNNING;
+                break;
+            case 2:
+                status = Status::FINISHED;
+                break;
+        }
+    }
+
+    if (json.contains(HOST_ID) && json[HOST_ID].isString()) {
+        host_id = json[HOST_ID].toString();
+    }
+
+    if (json.contains(PLAYERS) && json[PLAYERS].isArray()) {
+        for (auto obj : json[PLAYERS].toArray()) {
+            players.push_back(Player());
+            players.back().read(obj.toObject());
+        }
+    }
+}
+void SessionInfo::write(QJsonObject &json) const {
+    assert(false);  // Should not be used
+}
diff --git a/client/entities/sessioninfo.h b/client/entities/sessioninfo.h
new file mode 100644
index 00000000..80f2eb3a
--- /dev/null
+++ b/client/entities/sessioninfo.h
@@ -0,0 +1,38 @@
+#ifndef CAVOKE_SESSIONINFO_H
+#define CAVOKE_SESSIONINFO_H
+
+#include <QtCore/QJsonArray>
+#include <QtCore/QJsonObject>
+#include <QtCore/QString>
+#include <QtCore/QVector>
+#include "player.h"
+struct SessionInfo {
+    enum class Status { NOT_STARTED, RUNNING, FINISHED };
+
+public:
+    SessionInfo();
+    SessionInfo(QString _session_id,
+                QString _game_id,
+                SessionInfo::Status _status,
+                QString _host_id,
+                QVector<Player> _players);
+
+    void read(const QJsonObject &json);
+    void write(QJsonObject &json) const;
+
+    QString session_id;
+    QString game_id;
+    SessionInfo::Status status = Status::FINISHED;
+    QString host_id;
+    QVector<Player> players;
+    bool isHost = false;
+
+private:
+    static inline const QString SESSION_ID = "session_id";
+    static inline const QString GAME_ID = "game_id";
+    static inline const QString STATUS = "status";
+    static inline const QString HOST_ID = "host_id";
+    static inline const QString PLAYERS = "players";
+};
+
+#endif  // CAVOKE_SESSIONINFO_H
diff --git a/client/entities/user.cpp b/client/entities/user.cpp
new file mode 100644
index 00000000..b3a0d998
--- /dev/null
+++ b/client/entities/user.cpp
@@ -0,0 +1,20 @@
+#include "user.h"
+
+User::User() = default;
+
+User::User(QString _display_name, QString _user_id)
+    : display_name(std::move(_display_name)), user_id(std::move(_user_id)) {
+}
+
+void User::read(const QJsonObject &json) {
+    if (json.contains(DISPLAY_NAME) && json[DISPLAY_NAME].isString()) {
+        display_name = json[DISPLAY_NAME].toString();
+    }
+    if (json.contains(USER_ID) && json[USER_ID].isString()) {
+        user_id = json[USER_ID].toString();
+    }
+}
+
+void User::write(QJsonObject &json) {
+    assert(false);  // Should not be used
+}
diff --git a/client/entities/user.h b/client/entities/user.h
new file mode 100644
index 00000000..b57b0960
--- /dev/null
+++ b/client/entities/user.h
@@ -0,0 +1,22 @@
+#ifndef CAVOKE_USER_H
+#define CAVOKE_USER_H
+
+#include <QtCore/QJsonObject>
+#include <QtCore/QString>
+struct User {
+public:
+    User();
+    User(QString _display_name, QString _user_id);
+
+    void read(const QJsonObject &json);
+    static void write(QJsonObject &json);
+
+    QString display_name;
+    QString user_id;
+
+private:
+    static inline const QString DISPLAY_NAME = "display_name";
+    static inline const QString USER_ID = "user_id";
+};
+
+#endif  // CAVOKE_USER_H
diff --git a/client/entities/usergamestatistics.cpp b/client/entities/usergamestatistics.cpp
new file mode 100644
index 00000000..ff60f61e
--- /dev/null
+++ b/client/entities/usergamestatistics.cpp
@@ -0,0 +1,33 @@
+#include "usergamestatistics.h"
+#include <utility>
+
+UserGameStatistics::UserGameStatistics() = default;
+
+UserGameStatistics::UserGameStatistics(QString _game_id,
+                                       int _time_played_sec,
+                                       int _games_played,
+                                       double _win_rate)
+    : game_id(std::move(_game_id)),
+      time_played_sec(_time_played_sec),
+      games_played(_games_played),
+      win_rate(_win_rate) {
+}
+
+void UserGameStatistics::read(const QJsonObject &json) {
+    if (json.contains(GAME_ID) && json[GAME_ID].isString()) {
+        game_id = json[GAME_ID].toString();
+    }
+    if (json.contains(TIME_PLAYED_SEC) && json[TIME_PLAYED_SEC].isDouble()) {
+        time_played_sec = json[TIME_PLAYED_SEC].toInt();
+    }
+    if (json.contains(GAMES_PLAYED) && json[GAMES_PLAYED].isDouble()) {
+        games_played = json[GAMES_PLAYED].toInt();
+    }
+    if (json.contains(WIN_RATE) && json[WIN_RATE].isDouble()) {
+        win_rate = json[WIN_RATE].toDouble();
+    }
+}
+
+void UserGameStatistics::write(QJsonObject &json) {
+    assert(false);  // Should not be used
+}
diff --git a/client/entities/usergamestatistics.h b/client/entities/usergamestatistics.h
new file mode 100644
index 00000000..936f67e1
--- /dev/null
+++ b/client/entities/usergamestatistics.h
@@ -0,0 +1,29 @@
+#ifndef CAVOKE_USERGAMESTATISTICS_H
+#define CAVOKE_USERGAMESTATISTICS_H
+
+#include <QJsonObject>
+#include <QString>
+struct UserGameStatistics {
+public:
+    UserGameStatistics();
+    UserGameStatistics(QString _game_id,
+                       int _time_played_sec,
+                       int _games_played,
+                       double _win_rate);
+
+    void read(const QJsonObject &json);
+    static void write(QJsonObject &json);
+
+    QString game_id;
+    int time_played_sec = 0;
+    int games_played = 0;
+    double win_rate = 0;
+
+private:
+    static inline const QString GAME_ID = "game_id";
+    static inline const QString TIME_PLAYED_SEC = "time_played_sec";
+    static inline const QString GAMES_PLAYED = "games_played";
+    static inline const QString WIN_RATE = "win_rate";
+};
+
+#endif  // CAVOKE_USERGAMESTATISTICS_H
diff --git a/client/entities/userstatistics.cpp b/client/entities/userstatistics.cpp
new file mode 100644
index 00000000..91a4ffe0
--- /dev/null
+++ b/client/entities/userstatistics.cpp
@@ -0,0 +1,24 @@
+#include "userstatistics.h"
+
+UserStatistics::UserStatistics() = default;
+
+UserStatistics::UserStatistics(int _total_time_played_sec,
+                               int _total_games_played)
+    : total_time_played_sec(_total_time_played_sec),
+      total_games_played(_total_games_played) {
+}
+
+void UserStatistics::read(const QJsonObject &json) {
+    if (json.contains(TOTAL_TIME_PLAYED_SEC) &&
+        json[TOTAL_TIME_PLAYED_SEC].isDouble()) {
+        total_time_played_sec = json[TOTAL_TIME_PLAYED_SEC].toInt();
+    }
+    if (json.contains(TOTAL_GAMES_PLAYED) &&
+        json[TOTAL_GAMES_PLAYED].isDouble()) {
+        total_games_played = json[TOTAL_GAMES_PLAYED].toInt();
+    }
+}
+
+void UserStatistics::write(QJsonObject &json) {
+    assert(false);  // Should not be used
+}
diff --git a/client/entities/userstatistics.h b/client/entities/userstatistics.h
new file mode 100644
index 00000000..84dcd5a7
--- /dev/null
+++ b/client/entities/userstatistics.h
@@ -0,0 +1,22 @@
+#ifndef CAVOKE_USERSTATISTICS_H
+#define CAVOKE_USERSTATISTICS_H
+
+#include <QtCore/QJsonObject>
+#include <QtCore/QString>
+struct UserStatistics {
+public:
+    UserStatistics();
+    UserStatistics(int _total_time_played_sec, int _total_games_played);
+
+    void read(const QJsonObject &json);
+    static void write(QJsonObject &json);
+
+    int total_time_played_sec = 0;
+    int total_games_played = 0;
+
+private:
+    static inline const QString TOTAL_TIME_PLAYED_SEC = "total_time_played_sec";
+    static inline const QString TOTAL_GAMES_PLAYED = "total_games_played";
+};
+
+#endif  // CAVOKE_USERSTATISTICS_H
diff --git a/client/entities/validationresult.cpp b/client/entities/validationresult.cpp
new file mode 100644
index 00000000..7529dbdf
--- /dev/null
+++ b/client/entities/validationresult.cpp
@@ -0,0 +1,25 @@
+#include "validationresult.h"
+#include <utility>
+ValidationResult::ValidationResult() = default;
+ValidationResult::ValidationResult(bool _success, QString _message)
+    : success(_success), message(std::move(_message)) {
+}
+
+void ValidationResult::read(const QJsonObject &json) {
+    if (json.contains(SUCCESS) && json[SUCCESS].isBool()) {
+        success = json[SUCCESS].toBool();
+    }
+    if (success) {
+        message = "Now you can start the game!";
+    }
+    if (!success && json.contains(MESSAGE) && json[MESSAGE].isString()) {
+        message = json[MESSAGE].toString();
+    }
+}
+
+void ValidationResult::write(QJsonObject &json) const {
+    json[SUCCESS] = success;
+    if (!success) {
+        json[MESSAGE] = message;
+    }
+}
diff --git a/client/entities/validationresult.h b/client/entities/validationresult.h
new file mode 100644
index 00000000..20f0f1c6
--- /dev/null
+++ b/client/entities/validationresult.h
@@ -0,0 +1,22 @@
+#ifndef CAVOKE_VALIDATIONRESULT_H
+#define CAVOKE_VALIDATIONRESULT_H
+
+#include <QtCore/QJsonObject>
+#include <QtCore/QString>
+struct ValidationResult {
+public:
+    ValidationResult();
+    ValidationResult(bool _success, QString _message);
+
+    void read(const QJsonObject &json);
+    void write(QJsonObject &json) const;
+
+    bool success = false;
+    QString message = "Empty result";
+
+private:
+    static inline const QString SUCCESS = "success";
+    static inline const QString MESSAGE = "message";
+};
+
+#endif  // CAVOKE_VALIDATIONRESULT_H
diff --git a/client/gameinfo.cpp b/client/gameinfo.cpp
deleted file mode 100644
index 31965622..00000000
--- a/client/gameinfo.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "gameinfo.h"
-#include <utility>
-GameInfo::GameInfo() = default;
-GameInfo::GameInfo(QString _id,
-                   QString _display_name,
-                   QString _description,
-                   int _players_num)
-    : id(std::move(_id)),
-      display_name(std::move(_display_name)),
-      description(std::move(_description)),
-      players_num(_players_num) {
-}
-void GameInfo::read(const QJsonObject &json) {
-    if (json.contains("id") && json["id"].isString())
-        id = json["id"].toString();
-
-    if (json.contains("display_name") && json["display_name"].isString())
-        display_name = json["display_name"].toString();
-
-    if (json.contains("description") && json["description"].isString())
-        description = json["description"].toString();
-
-    if (json.contains("players_num") && json["players_num"].isDouble())
-        players_num = json["players_num"].toInt();
-}
-void GameInfo::write(QJsonObject &json) const {
-    json["id"] = id;
-    json["display_name"] = display_name;
-    json["description"] = description;
-    json["players_num"] = players_num;
-}
diff --git a/client/main.cpp b/client/main.cpp
index 80fea92b..94417f3f 100644
--- a/client/main.cpp
+++ b/client/main.cpp
@@ -3,6 +3,9 @@
 
 int main(int argc, char *argv[]) {
     QApplication a(argc, argv);
+    QCoreApplication::setOrganizationName("Cavoke");
+    QCoreApplication::setOrganizationDomain("cavoke.wlko.me");
+    QCoreApplication::setApplicationName("Cavoke");
     CavokeClientController c(&a);
     return a.exec();
 }
diff --git a/client/models/cavokeclientmodel.cpp b/client/models/cavokeclientmodel.cpp
index 9a22ffd1..46584fd7 100644
--- a/client/models/cavokeclientmodel.cpp
+++ b/client/models/cavokeclientmodel.cpp
@@ -16,13 +16,15 @@ void CavokeClientModel::loadQmlGame(const QString &gameId) {
 }
 void CavokeClientModel::updateGamesList(const QJsonArray &newGamesList) {
     std::vector<GameInfo> got_from;
-    for (auto obj : newGamesList) {
-        got_from.emplace_back(GameInfo());
-        got_from.back().read(obj.toObject());
-    }
-    gamesList = got_from;
-
-    if (!gamesList.empty()) {
+    std::transform(newGamesList.begin(), newGamesList.end(),
+                   std::back_inserter(got_from), [](const QJsonValue &obj) {
+                       GameInfo game_info;
+                       game_info.read(obj.toObject());
+                       return game_info;
+                   });
+    gamesList = std::move(got_from);
+
+    if (!newGamesList.empty()) {
         qDebug() << "First In Model: " << gamesList[0].id;
     }
     emit gamesListUpdated(gamesList);
@@ -39,8 +41,8 @@ void CavokeClientModel::gotIndexToDownload(int index) {
     gotGameIdToDownload(gamesList[index].id);
 }
 
-QString CavokeClientModel::getGameIdByIndex(int index) {
-    return gamesList[index].id;
+GameInfo CavokeClientModel::getGameByIndex(int index) {
+    return gamesList[index];
 }
 
 void CavokeClientModel::gotGameIdToDownload(const QString &gameId) {
diff --git a/client/models/cavokeclientmodel.h b/client/models/cavokeclientmodel.h
index c559b443..cb4a5838 100644
--- a/client/models/cavokeclientmodel.h
+++ b/client/models/cavokeclientmodel.h
@@ -3,14 +3,14 @@
 
 #include <QObject>
 #include "cavokeqmlgamemodel.h"
-#include "gameinfo.h"
+#include "entities/gameinfo.h"
 
 class CavokeClientModel : public QObject {
     Q_OBJECT
 
 public:
     explicit CavokeClientModel(QObject *parent = nullptr);
-    QString getGameIdByIndex(int index);  // FIXME: oh no, cringe
+    GameInfo getGameByIndex(int index);  // FIXME: oh no, cringe
 public slots:
     void loadQmlGame(const QString &gameId);
     void updateGamesList(const QJsonArray &newGamesList);
diff --git a/client/network_manager.cpp b/client/network_manager.cpp
index 1107f123..19fbd0cf 100644
--- a/client/network_manager.cpp
+++ b/client/network_manager.cpp
@@ -1,14 +1,28 @@
 #include "network_manager.h"
 
-NetworkManager::NetworkManager(QObject *parent) : manager(parent) {
-    pollingTimer = new QTimer(this);
-    pollingTimer->setInterval(500);
-    pollingTimer->callOnTimeout([this]() { getUpdate(); });
-    userId = QUuid::createUuid();
+NetworkManager::NetworkManager(QObject *parent)
+    : manager{this},
+      oauth2{&cavoke::auth::AuthenticationManager::getInstance().oauth2} {
+    gamePollingTimer = new QTimer(this);
+    gamePollingTimer->setInterval(500);
+    gamePollingTimer->callOnTimeout([this]() { getPlayState(); });
+    sessionPollingTimer = new QTimer(this);
+    sessionPollingTimer->setInterval(500);
+    sessionPollingTimer->callOnTimeout([this]() { getSessionInfo(); });
+    validationPollingTimer = new QTimer(this);
+    validationPollingTimer->setInterval(500);
+    validationPollingTimer->callOnTimeout([this]() { validateSession(); });
+    roomPollingTimer = new QTimer(this);
+    roomPollingTimer->setInterval(500);
+    roomPollingTimer->callOnTimeout([this]() { getRoomInfo(); });
+    // generate randomly for local server mode
+    queryUserId = QUuid::createUuid().toString(QUuid::WithoutBraces);
+
+    oauth2->setNetworkAccessManager(&manager);
 }
 
 void NetworkManager::getHealth() {
-    auto reply = manager.get(QNetworkRequest(HOST.resolved(HEALTH)));
+    auto reply = oauth2->get(HOST.resolved(HEALTH));
     connect(reply, &QNetworkReply::finished, this,
             [reply, this]() { gotHealth(reply); });
 }
@@ -21,7 +35,7 @@ void NetworkManager::gotHealth(QNetworkReply *reply) {
 }
 
 void NetworkManager::getGamesList() {
-    auto reply = manager.get(QNetworkRequest(HOST.resolved(GAMES_LIST)));
+    auto reply = oauth2->get(HOST.resolved(GAMES_LIST));
     connect(reply, &QNetworkReply::finished, this,
             [reply, this]() { gotGamesList(reply); });
 }
@@ -38,24 +52,32 @@ void NetworkManager::gotGamesList(QNetworkReply *reply) {
 void NetworkManager::getGamesConfig(const QString &gameId) {
     QUrl route =
         HOST.resolved(GAMES).resolved(gameId + "/").resolved(GET_CONFIG);
-    auto request = QNetworkRequest(route);
-    auto reply = manager.get(request);
+    route.setQuery({{"user_id", getUserId()}});
+    auto reply = oauth2->get(route);
     connect(reply, &QNetworkReply::finished, this,
             [reply, this]() { gotGamesConfig(reply); });
 }
 
 void NetworkManager::gotGamesConfig(QNetworkReply *reply) {
-    qDebug() << "Got Games Config:";
-    qDebug() << reply->readAll();
-    qDebug() << "Not implemented yet!!";
+    if (reply->error()) {
+        qDebug() << reply->errorString();
+        return;
+    }
+    QByteArray answer = reply->readAll();
+    reply->close();
+    reply->deleteLater();
+    qDebug() << answer;
+    GameInfo gameInfo;
+    gameInfo.read(QJsonDocument::fromJson(answer).object());
+    emit gotGameInfo(gameInfo);
 }
 
 void NetworkManager::getGamesClient(const QString &gameId) {
     QUrl route =
         HOST.resolved(GAMES).resolved(gameId + "/").resolved(GET_CLIENT);
+    route.setQuery({{"user_id", getUserId()}});
     qDebug() << route.toString();
-    auto request = QNetworkRequest(route);
-    auto reply = manager.get(request);
+    auto reply = oauth2->get(route);
     connect(reply, &QNetworkReply::finished, this,
             [reply, gameId, this]() { gotGamesClient(reply, gameId); });
 }
@@ -79,90 +101,334 @@ void NetworkManager::gotGamesClient(QNetworkReply *reply,
     reply->deleteLater();
 }
 
-void NetworkManager::createSession(const QString &gameId) {
-    QUrl route = HOST.resolved(SESSIONS_CREATE);
-    route.setQuery({{"game_id", gameId},
-                    {"user_id", userId.toString(QUuid::WithoutBraces)}});
+void NetworkManager::sendMove(const QString &jsonMove) {
+    QUrl route =
+        HOST.resolved(PLAY).resolved(sessionId + "/").resolved(SEND_MOVE);
+    route.setQuery({{"user_id", getUserId()}});
     qDebug() << route.toString();
-    auto request = QNetworkRequest(route);
-    request.setHeader(QNetworkRequest::KnownHeaders::ContentTypeHeader,
-                      "application/json");
-    auto reply = manager.post(request, "{}");
+    auto reply = oauth2->post(route, jsonMove.toUtf8());
     connect(reply, &QNetworkReply::finished, this,
-            [reply, this]() { gotSession(reply); });
+            [reply, this]() { gotPostResponse(reply); });
+}
+
+void NetworkManager::gotPostResponse(QNetworkReply *reply) {
+    QByteArray answer = reply->readAll();
+    reply->close();
+    reply->deleteLater();
+    qDebug() << "Got some post response: " << answer;
 }
 
-void NetworkManager::joinSession(const QString &inviteCode) {
-    QUrl route = HOST.resolved(SESSIONS_JOIN);
-    route.setQuery({{"user_id", userId.toString(QUuid::WithoutBraces)},
-                    {"invite_code", inviteCode}});
+void NetworkManager::getPlayState() {
+    QUrl route =
+        HOST.resolved(PLAY).resolved(sessionId + "/").resolved(GET_STATE);
+    route.setQuery({{"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->get(route);
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotPlayState(reply); });
+}
+
+void NetworkManager::gotPlayState(QNetworkReply *reply) {
+    if (reply->error()) {
+        qDebug() << reply->errorString();
+        return;
+    }
+    QString answer = reply->readAll();
+    reply->close();
+    reply->deleteLater();
+    qDebug() << answer;
+    emit gotGameUpdate(answer);
+}
+
+void NetworkManager::joinSession(const QString &sessionId) {
+    QUrl route =
+        HOST.resolved(SESSIONS).resolved(sessionId + "/").resolved(JOIN);
+    route.setQuery({{"user_id", getUserId()}});
     qDebug() << route.toString();
-    auto request = QNetworkRequest(route);
-    request.setHeader(QNetworkRequest::KnownHeaders::ContentTypeHeader,
-                      "application/json");
-    auto reply = manager.post(request, "{}");
+    auto reply = oauth2->post(route, "{}");
     connect(reply, &QNetworkReply::finished, this,
             [reply, this]() { gotSession(reply); });
 }
 
 void NetworkManager::gotSession(QNetworkReply *reply) {
     QByteArray answer = reply->readAll();
+    if (reply->error()) {
+        qDebug() << "Session ERROR:" << reply->errorString();
+    }
     reply->close();
     reply->deleteLater();
-    qDebug() << answer;
+    qDebug() << "Got session: " << answer;
 
     SessionInfo sessionInfo;
     sessionInfo.read(QJsonDocument::fromJson(answer).object());
     sessionId = sessionInfo.session_id;
+    sessionInfo.isHost =
+        sessionInfo.host_id ==
+        queryUserId;  // using explicitly query user_id, as in prod mode it is
+                      // returned from the server
+
     emit gotSessionInfo(sessionInfo);
 }
 
-void NetworkManager::sendMove(const QString &jsonMove) {
+void NetworkManager::validateSession() {
     QUrl route =
-        HOST.resolved(PLAY).resolved(sessionId + "/").resolved(SEND_MOVE);
-    route.setQuery({{"user_id", userId.toString(QUuid::WithoutBraces)}});
+        HOST.resolved(SESSIONS).resolved(sessionId + "/").resolved(VALIDATE);
+    route.setQuery({{"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->post(route, "{}");
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotValidatedSession(reply); });
+}
+
+void NetworkManager::gotValidatedSession(QNetworkReply *reply) {
+    QByteArray answer = reply->readAll();
+    reply->close();
+    reply->deleteLater();
+    //    qDebug() << answer;
+
+    ValidationResult validationResult;
+    validationResult.read(QJsonDocument::fromJson(answer).object());
+
+    emit gotValidationResult(validationResult);
+}
+
+void NetworkManager::getSessionInfo() {
+    QUrl route =
+        HOST.resolved(SESSIONS).resolved(sessionId + "/").resolved(GET_INFO);
+    route.setQuery({{"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->get(route);
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotSession(reply); });
+}
+
+void NetworkManager::getSessionInfo(const QString &other_sessionId) {
+    QUrl route = HOST.resolved(SESSIONS)
+                     .resolved(other_sessionId + "/")
+                     .resolved(GET_INFO);
+    route.setQuery({{"user_id", getUserId()}});
     qDebug() << route.toString();
-    auto request = QNetworkRequest(route);
-    request.setHeader(QNetworkRequest::KnownHeaders::ContentTypeHeader,
-                      "application/json");
-    auto reply = manager.post(request, jsonMove.toUtf8());
+    auto reply = oauth2->get(route);
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotSession(reply); });
+}
+
+void NetworkManager::startSession() {
+    QUrl route =
+        HOST.resolved(SESSIONS).resolved(sessionId + "/").resolved(START);
+    route.setQuery({{"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->post(route, "{}");
     connect(reply, &QNetworkReply::finished, this,
             [reply, this]() { gotPostResponse(reply); });
 }
 
-void NetworkManager::gotPostResponse(QNetworkReply *reply) {
+void NetworkManager::leaveSession() {
+    QUrl route =
+        HOST.resolved(SESSIONS).resolved(sessionId + "/").resolved(LEAVE);
+    route.setQuery({{"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->post(route, "{}");
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotPostResponse(reply); });
+}
+
+void NetworkManager::changeRoleInSession(int newRole) {
+    QUrl route =
+        HOST.resolved(SESSIONS).resolved(sessionId + "/").resolved(CHANGE_ROLE);
+    route.setQuery(
+        {{"user_id", getUserId()}, {"new_role", QString::number(newRole)}});
+    qDebug() << route.toString();
+    auto reply = oauth2->post(route, "{}");
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotPostResponse(reply); });
+}
+
+void NetworkManager::getRoomInfo() {
+    QUrl route = HOST.resolved(ROOMS).resolved(roomId + "/").resolved(GET_INFO);
+    route.setQuery({{"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->get(route);
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotRoom(reply); });
+}
+
+void NetworkManager::gotRoom(QNetworkReply *reply) {
     QByteArray answer = reply->readAll();
     reply->close();
     reply->deleteLater();
-    qDebug() << "Got some post response: " << answer;
+    qDebug() << "Got room: " << answer;
+
+    RoomInfo roomInfo;
+    roomInfo.read(QJsonDocument::fromJson(answer).object());
+    roomId = roomInfo.room_id;
+    roomInfo.isHost = roomInfo.host_id == queryUserId;
+
+    emit gotRoomInfo(roomInfo);
 }
 
-void NetworkManager::getUpdate() {
+void NetworkManager::createRoom(const QString &display_name) {
+    QUrl route = HOST.resolved(ROOMS_CREATE);
+    route.setQuery({{"display_name", display_name}, {"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->post(route, "{}");
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotRoom(reply); });
+}
+
+void NetworkManager::joinRoom(const QString &inviteCode) {
+    QUrl route = HOST.resolved(ROOMS_JOIN);
+    route.setQuery({{"user_id", getUserId()}, {"invite_code", inviteCode}});
+    qDebug() << route.toString();
+    auto reply = oauth2->post(route, "{}");
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotRoom(reply); });
+}
+
+void NetworkManager::leaveRoom() {
+    QUrl route = HOST.resolved(ROOMS).resolved(roomId + "/").resolved(LEAVE);
+    route.setQuery({{"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->post(route, "{}");
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotPostResponse(reply); });
+}
+
+void NetworkManager::roomCreateSession(const QString &game_id) {
     QUrl route =
-        HOST.resolved(PLAY).resolved(sessionId + "/").resolved(GET_STATE);
-    route.setQuery({{"user_id", userId.toString(QUuid::WithoutBraces)}});
+        HOST.resolved(ROOMS).resolved(roomId + "/").resolved(CREATE_SESSION);
+    route.setQuery({{"user_id", getUserId()}, {"game_id", game_id}});
+    auto reply = oauth2->post(route, "{}");
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotSession(reply); });
+}
+
+void NetworkManager::getMe() {
+    QUrl route = HOST.resolved(PROFILE).resolved(GET_ME);
+    route.setQuery({{"user_id", getUserId()}});
     qDebug() << route.toString();
-    auto request = QNetworkRequest(route);
-    auto reply = manager.get(request);
+    auto reply = oauth2->get(route);
     connect(reply, &QNetworkReply::finished, this,
-            [reply, this]() { gotUpdate(reply); });
+            [reply, this]() { gotMyself(reply); });
 }
 
-void NetworkManager::gotUpdate(QNetworkReply *reply) {
-    if (reply->error()) {
-        qDebug() << reply->errorString();
-        return;
-    }
-    QString answer = reply->readAll();
+void NetworkManager::gotMyself(QNetworkReply *reply) {
+    QByteArray answer = reply->readAll();
     reply->close();
     reply->deleteLater();
-    qDebug() << answer;
-    emit gotGameUpdate(answer);
+    qDebug() << "Got my profile: " << answer;
+
+    User userInfo;
+    userInfo.read(QJsonDocument::fromJson(answer).object());
+    // update my user id used in query params
+    queryUserId = userInfo.user_id;
+    emit gotDisplayName(userInfo.display_name);
+}
+
+void NetworkManager::changeName(const QString &new_name) {
+    QUrl route = HOST.resolved(PROFILE).resolved(CHANGE_NAME);
+    route.setQuery({{"user_id", getUserId()}, {"new_name", new_name}});
+    qDebug() << route.toString();
+    auto reply = oauth2->post(route);
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotPostResponse(reply); });
 }
-void NetworkManager::startPolling() {
-    pollingTimer->start();
+
+void NetworkManager::getMyUserStatistics() {
+    QUrl route = HOST.resolved(PROFILE).resolved(MY_USER_STATISTICS);
+    route.setQuery({{"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->get(route);
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotUserStatistics(reply); });
 }
 
-void NetworkManager::stopPolling() {
-    pollingTimer->stop();
+void NetworkManager::gotUserStatistics(QNetworkReply *reply) {
+    QByteArray answer = reply->readAll();
+    reply->close();
+    reply->deleteLater();
+    qDebug() << "Got my user statistics: " << answer;
+
+    UserStatistics userStatistics;
+    userStatistics.read(QJsonDocument::fromJson(answer).object());
+    emit gotUserStatistics(userStatistics);
+}
+
+void NetworkManager::getMyUserGameStatistics(const QString &gameId) {
+    QUrl route = HOST.resolved(PROFILE)
+                     .resolved(MY_USER_GAME_STATISTICS)
+                     .resolved(gameId);
+    route.setQuery({{"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->get(route);
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotUserGameStatistics(reply); });
+}
+
+void NetworkManager::gotUserGameStatistics(QNetworkReply *reply) {
+    QByteArray answer = reply->readAll();
+    reply->close();
+    reply->deleteLater();
+    qDebug() << "Got my user game statistics: " << answer;
+
+    UserGameStatistics userGameStatistics;
+    userGameStatistics.read(QJsonDocument::fromJson(answer).object());
+    emit gotUserGameStatistics(userGameStatistics);
+}
+
+void NetworkManager::getGameStatistics(const QString &gameId) {
+    QUrl route = HOST.resolved(STATISTICS_GAME).resolved(gameId);
+    route.setQuery({{"user_id", getUserId()}});
+    qDebug() << route.toString();
+    auto reply = oauth2->get(route);
+    connect(reply, &QNetworkReply::finished, this,
+            [reply, this]() { gotGameStatistics(reply); });
+}
+
+void NetworkManager::gotGameStatistics(QNetworkReply *reply) {
+    QByteArray answer = reply->readAll();
+    reply->close();
+    reply->deleteLater();
+    qDebug() << "Got game statistics: " << answer;
+
+    GameStatistics gameStatistics;
+    gameStatistics.read(QJsonDocument::fromJson(answer).object());
+    emit gotGameStatistics(gameStatistics);
+}
+
+void NetworkManager::startGamePolling() {
+    gamePollingTimer->start();
+}
+
+void NetworkManager::stopGamePolling() {
+    gamePollingTimer->stop();
+}
+
+void NetworkManager::startSessionPolling() {
+    sessionPollingTimer->start();
+}
+void NetworkManager::stopSessionPolling() {
+    sessionPollingTimer->stop();
+}
+void NetworkManager::startValidationPolling() {
+    validationPollingTimer->start();
+}
+
+void NetworkManager::stopValidationPolling() {
+    validationPollingTimer->stop();
+}
+
+void NetworkManager::startRoomPolling() {
+    roomPollingTimer->start();
+}
+
+void NetworkManager::stopRoomPolling() {
+    roomPollingTimer->stop();
+}
+void NetworkManager::changeHost(const QUrl &newHost) {
+    HOST = newHost;
+    getGamesList();
+}
+QString NetworkManager::getUserId() {
+    return queryUserId;
 }
diff --git a/client/network_manager.h b/client/network_manager.h
index 7db099fa..f96ed554 100644
--- a/client/network_manager.h
+++ b/client/network_manager.h
@@ -1,71 +1,147 @@
 #ifndef CAVOKE_CLIENT_NETWORK_MANAGER_H
 #define CAVOKE_CLIENT_NETWORK_MANAGER_H
 
+#include <QOAuth2AuthorizationCodeFlow>
 #include <QUrlQuery>
+#include <QUuid>
 #include <QtCore/QFile>
 #include <QtCore/QJsonArray>
 #include <QtCore/QJsonDocument>
 #include <QtCore/QJsonObject>
 #include <QtCore/QTemporaryFile>
 #include <QtCore/QTimer>
-#include <QtNetwork/QNetworkAccessManager>
 #include <QtNetwork/QNetworkReply>
-#include "sessioninfo.h"
+#include "AuthenticationManager.h"
+#include "entities/gameinfo.h"
+#include "entities/gamestatistics.h"
+#include "entities/roominfo.h"
+#include "entities/sessioninfo.h"
+#include "entities/usergamestatistics.h"
+#include "entities/userstatistics.h"
+#include "entities/validationresult.h"
+
 struct NetworkManager : public QObject {
     Q_OBJECT
 public:
+    const static inline QUrl DEFAULT_HOST{"https://develop.api.cavoke.wlko.me"};
     explicit NetworkManager(QObject *parent = nullptr);
+    void changeHost(const QUrl &newHost);
+    QString getUserId();
 
 public slots:
     void getHealth();
+
     void getGamesList();
     void getGamesConfig(const QString &gameId);
     void getGamesClient(const QString &gameId);
-    void createSession(const QString &gameId);
-    void joinSession(const QString &inviteCode);
+
     void sendMove(const QString &jsonMove);
-    void getUpdate();
+    void getPlayState();
+
+    void joinSession(const QString &sessionId);
+    void validateSession();
+    void getSessionInfo();
+    void getSessionInfo(const QString &sessionId);
+    void startSession();
+    void leaveSession();
+    void changeRoleInSession(int newRole);
+
+    void getRoomInfo();
+    void createRoom(const QString &display_name);
+    void joinRoom(const QString &invite_code);
+    void leaveRoom();
+    void roomCreateSession(const QString &game_id);
+
+    void getMe();
+    void changeName(const QString &new_name);
 
-    void startPolling();
-    void stopPolling();
+    void getMyUserStatistics();
+    void getMyUserGameStatistics(const QString &gameId);
+    void getGameStatistics(const QString &gameId);
+
+    void startGamePolling();
+    void stopGamePolling();
+    void startSessionPolling();
+    void stopSessionPolling();
+    void startValidationPolling();
+    void stopValidationPolling();
+    void startRoomPolling();
+    void stopRoomPolling();
 
 signals:
     void finalizedGamesList(QJsonArray list);
     void gotGameUpdate(const QString &jsonField);
     void downloadedGameFile(QFile *file, const QString &gameId);
+    void gotGameInfo(const GameInfo &gameInfo);
     void gotSessionInfo(const SessionInfo &sessionInfo);
+    void gotValidationResult(const ValidationResult &validationResult);
+    void gotDisplayName(const QString &displayName);
+    void gotUserStatistics(const UserStatistics &userStatistics);
+    void gotUserGameStatistics(const UserGameStatistics &userGameStatistics);
+    void gotGameStatistics(const GameStatistics &gameStatistics);
+    void gotRoomInfo(const RoomInfo &roomInfo);
 
 private slots:
     void gotHealth(QNetworkReply *reply);
     void gotGamesList(QNetworkReply *reply);
     void gotGamesConfig(QNetworkReply *reply);
     void gotSession(QNetworkReply *reply);
+    void gotValidatedSession(QNetworkReply *reply);
     void gotPostResponse(QNetworkReply *reply);
-    void gotUpdate(QNetworkReply *reply);
+    void gotPlayState(QNetworkReply *reply);
     void gotGamesClient(QNetworkReply *reply, const QString &gameId);
+    void gotMyself(QNetworkReply *reply);
+    void gotUserStatistics(QNetworkReply *reply);
+    void gotUserGameStatistics(QNetworkReply *reply);
+    void gotGameStatistics(QNetworkReply *reply);
+    void gotRoom(QNetworkReply *reply);
 
 private:
+    QOAuth2AuthorizationCodeFlow *oauth2;
     QNetworkAccessManager manager;
-    QTimer *pollingTimer = nullptr;
+    QTimer *gamePollingTimer = nullptr;
+    QTimer *sessionPollingTimer = nullptr;
+    QTimer *validationPollingTimer = nullptr;
+    QTimer *roomPollingTimer = nullptr;
     QString sessionId;
-    QUuid userId;
-    const static inline QUrl HOST{
-#ifdef MOCK
-        "https://764bbfca-c45a-46fc-9c79-11d9094b9ba8.mock.pstmn.io/"
-#else
-        "http://127.0.0.1:8080/"
-#endif
-    };
-    const static inline QUrl HEALTH{"health"};  // FIXME: move to routes module
+    QString roomId;
+    /// `user_id` query param.
+    /// For local servers (without jwt) is generated randomly through QUuid.
+    /// For prod servers (with jwt) is acquired from the server (through
+    /// `get_me`).
+    QString queryUserId;
+    QUrl HOST{DEFAULT_HOST};
+    const static inline QUrl HEALTH{"health"};
     const static inline QUrl GAMES_LIST{"games/list"};
     const static inline QUrl GAMES{"games/"};
     const static inline QUrl GET_CONFIG{"get_config"};
     const static inline QUrl GET_CLIENT{"get_client"};
-    const static inline QUrl SESSIONS_CREATE{"sessions/create"};
-    const static inline QUrl SESSIONS_JOIN{"sessions/join"};
+    // Rooms activity
+    const static inline QUrl ROOMS{"rooms/"};
+    const static inline QUrl GET_INFO{"get_info"};
+    const static inline QUrl ROOMS_CREATE{"rooms/create"};
+    const static inline QUrl ROOMS_JOIN{"rooms/join"};
+    const static inline QUrl LEAVE{"leave"};
+    const static inline QUrl CREATE_SESSION{"create_session"};
+
+    const static inline QUrl JOIN{"join"};
+    const static inline QUrl SESSIONS{"sessions/"};
+    const static inline QUrl VALIDATE{"validate"};
+    const static inline QUrl START{"start"};
+    const static inline QUrl CHANGE_ROLE{"change_role"};
+
     const static inline QUrl PLAY{"play/"};
     const static inline QUrl SEND_MOVE{"send_move"};
     const static inline QUrl GET_STATE{"get_state"};
+
+    const static inline QUrl PROFILE{"profile/"};
+    const static inline QUrl GET_ME{"get_me"};
+    const static inline QUrl CHANGE_NAME{"change_name"};
+    const static inline QUrl MY_USER_STATISTICS{"my_user_statistics"};
+    const static inline QUrl MY_USER_GAME_STATISTICS{
+        "my_user_game_statistics/"};
+
+    const static inline QUrl STATISTICS_GAME{"statistics/game/"};
 };
 
 #endif  // CAVOKE_CLIENT_NETWORK_MANAGER_H
diff --git a/client/resource.qrc b/client/resource.qrc
deleted file mode 100644
index e12eccc8..00000000
--- a/client/resource.qrc
+++ /dev/null
@@ -1,11 +0,0 @@
-<RCC>
-    <qresource prefix="/">
-        <file>tictactoe-files/tic-tac-toe.qml</file>
-        <file>tictactoe-files/content/Button.qml</file>
-        <file>tictactoe-files/content/TicTac.qml</file>
-        <file>tictactoe-files/content/interactions.js</file>
-        <file>tictactoe-files/content/pics/board.png</file>
-        <file>tictactoe-files/content/pics/o.png</file>
-        <file>tictactoe-files/content/pics/x.png</file>
-    </qresource>
-</RCC>
diff --git a/client/resources/images/cavoke_64.png b/client/resources/images/cavoke_64.png
new file mode 100644
index 00000000..91dd65eb
Binary files /dev/null and b/client/resources/images/cavoke_64.png differ
diff --git a/client/resources/images/info_48.png b/client/resources/images/info_48.png
new file mode 100644
index 00000000..39dc9ce2
Binary files /dev/null and b/client/resources/images/info_48.png differ
diff --git a/client/resources/packaging/128-apps-cavoke.png b/client/resources/packaging/128-apps-cavoke.png
new file mode 100644
index 00000000..c1bf0ab0
Binary files /dev/null and b/client/resources/packaging/128-apps-cavoke.png differ
diff --git a/client/resources/packaging/32-apps-cavoke.png b/client/resources/packaging/32-apps-cavoke.png
new file mode 100644
index 00000000..625b0cf3
Binary files /dev/null and b/client/resources/packaging/32-apps-cavoke.png differ
diff --git a/client/resources/packaging/64-apps-cavoke.png b/client/resources/packaging/64-apps-cavoke.png
new file mode 100644
index 00000000..91dd65eb
Binary files /dev/null and b/client/resources/packaging/64-apps-cavoke.png differ
diff --git a/client/resources/packaging/cavoke.ico b/client/resources/packaging/cavoke.ico
new file mode 100644
index 00000000..d55aab26
Binary files /dev/null and b/client/resources/packaging/cavoke.ico differ
diff --git a/client/resources/resources.qrc b/client/resources/resources.qrc
new file mode 100644
index 00000000..0b0e7747
--- /dev/null
+++ b/client/resources/resources.qrc
@@ -0,0 +1,6 @@
+<RCC>
+    <qresource prefix="/">
+        <file alias="cavoke">images/cavoke_64.png</file>
+        <file alias="info">images/info_48.png</file>
+    </qresource>
+</RCC>
diff --git a/client/sessioninfo.cpp b/client/sessioninfo.cpp
deleted file mode 100644
index 09961c89..00000000
--- a/client/sessioninfo.cpp
+++ /dev/null
@@ -1,28 +0,0 @@
-#include "sessioninfo.h"
-#include <utility>
-SessionInfo::SessionInfo() = default;
-SessionInfo::SessionInfo(QString _game_id,
-                         QString _session_id,
-                         QString _invite_code)
-    : game_id(std::move(_game_id)),
-      session_id(std::move(_session_id)),
-      invite_code(std::move(_invite_code)) {
-}
-void SessionInfo::read(const QJsonObject &json) {
-    if (json.contains(GAME_ID) && json[GAME_ID].isString()) {
-        game_id = json[GAME_ID].toString();
-    }
-
-    if (json.contains(SESSION_ID) && json[SESSION_ID].isString()) {
-        session_id = json[SESSION_ID].toString();
-    }
-
-    if (json.contains(INVITE_CODE) && json[INVITE_CODE].isString()) {
-        invite_code = json[INVITE_CODE].toString();
-    }
-}
-void SessionInfo::write(QJsonObject &json) const {
-    json[GAME_ID] = game_id;
-    json[SESSION_ID] = session_id;
-    json[INVITE_CODE] = invite_code;
-}
diff --git a/client/sessioninfo.h b/client/sessioninfo.h
deleted file mode 100644
index 572dffa8..00000000
--- a/client/sessioninfo.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef CAVOKE_SESSIONINFO_H
-#define CAVOKE_SESSIONINFO_H
-
-#include <QtCore/QJsonObject>
-#include <QtCore/QString>
-struct SessionInfo {
-public:
-    SessionInfo();
-    SessionInfo(QString _game_id, QString _session_id, QString _invite_code);
-
-    void read(const QJsonObject &json);
-    void write(QJsonObject &json) const;
-
-    QString game_id;
-    QString session_id;
-    QString invite_code;
-
-private:
-    static inline const QString GAME_ID = "game_id";
-    static inline const QString SESSION_ID = "session_id";
-    static inline const QString INVITE_CODE = "invite_code";
-};
-
-#endif  // CAVOKE_SESSIONINFO_H
diff --git a/client/tictactoe-files/content/pics/x.png b/client/tictactoe-files/content/pics/x.png
index 19506ee7..be59260a 100644
Binary files a/client/tictactoe-files/content/pics/x.png and b/client/tictactoe-files/content/pics/x.png differ
diff --git a/client/tictactoe-files/tic-tac-toe.qml b/client/tictactoe-files/tic-tac-toe.qml
index a0d325be..57f3efe5 100644
--- a/client/tictactoe-files/tic-tac-toe.qml
+++ b/client/tictactoe-files/tic-tac-toe.qml
@@ -88,19 +88,6 @@ Rectangle {
         Row {
             spacing: 4
             anchors.horizontalCenter: parent.horizontalCenter
-
-            Button {
-                text: "Hard"
-                onClicked: { cavoke.getMoveFromQml("D 1.0"); }
-            }
-            Button {
-                text: "Moderate"
-                onClicked: { cavoke.getMoveFromQml("D 0.8"); }
-            }
-            Button {
-                text: "Easy"
-                onClicked: { cavoke.getMoveFromQml("D 0.2"); }
-            }
         }
     }
 
diff --git a/client/views/authdialog.cpp b/client/views/authdialog.cpp
new file mode 100644
index 00000000..cb9696d3
--- /dev/null
+++ b/client/views/authdialog.cpp
@@ -0,0 +1,37 @@
+#include "authdialog.h"
+#include "ui_authdialog.h"
+
+AuthDialog::AuthDialog(QWidget *parent)
+    : ui(new Ui::AuthDialog), QDialog(parent) {
+    ui->setupUi(this);
+}
+
+AuthDialog::~AuthDialog() {
+    delete ui;
+}
+
+void AuthDialog::on_acceptButton_clicked() {
+    // connect authenticated status with dialog's successful closing
+    connect(authManager, &cavoke::auth::AuthenticationManager::authenticated,
+            this, &AuthDialog::accept);
+    // authorize through browser
+    authManager->oauth2.grant();
+}
+
+void AuthDialog::on_declineButton_clicked() {
+    qWarning() << "User declined authorization! Unable to proceed.";
+    QDialog::reject();
+}
+
+/// Auth guard for methods that require authentication (e.g. session creation)
+/// @returns `true` if authenticated successfully, `false` otherwise
+bool AuthDialog::verifyAuth(QWidget *parent) {
+    auto *authManager = &cavoke::auth::AuthenticationManager::getInstance();
+    // check if user already logged in
+    if (authManager->checkAuthStatus()) {
+        qDebug() << "Already authenticated";
+        return true;
+    }
+    // otherwise launch the dialog and ask the user to log in
+    return AuthDialog(parent).exec() == 1;
+}
diff --git a/client/views/authdialog.h b/client/views/authdialog.h
new file mode 100644
index 00000000..c6a4fbdf
--- /dev/null
+++ b/client/views/authdialog.h
@@ -0,0 +1,34 @@
+#ifndef AUTHDIALOG_H
+#define AUTHDIALOG_H
+
+#include <QDebug>
+#include <QDialog>
+#include "AuthenticationManager.h"
+
+namespace Ui {
+class AuthDialog;
+}
+
+/// Dialog that asks users to log in in order to use methods that require
+/// authentication.
+class AuthDialog : public QDialog {
+    Q_OBJECT
+
+public:
+    explicit AuthDialog(QWidget *parent = nullptr);
+    ~AuthDialog();
+
+    static bool verifyAuth(QWidget *parent = nullptr);
+
+private slots:
+    void on_acceptButton_clicked();
+
+    void on_declineButton_clicked();
+
+private:
+    Ui::AuthDialog *ui;
+    cavoke::auth::AuthenticationManager *authManager =
+        &cavoke::auth::AuthenticationManager::getInstance();
+};
+
+#endif  // AUTHDIALOG_H
diff --git a/client/views/authdialog.ui b/client/views/authdialog.ui
new file mode 100644
index 00000000..a6aa0ea9
--- /dev/null
+++ b/client/views/authdialog.ui
@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>AuthDialog</class>
+ <widget class="QDialog" name="AuthDialog">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>274</width>
+    <height>147</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Sign in</string>
+  </property>
+  <property name="modal">
+   <bool>true</bool>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <widget class="QLabel" name="label">
+     <property name="text">
+      <string>Sign in to complete this operation</string>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignCenter</set>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QPushButton" name="acceptButton">
+       <property name="text">
+        <string>Authorize with browser</string>
+       </property>
+       <property name="default">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="declineButton">
+       <property name="text">
+        <string>Cancel</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/client/views/creategameview.cpp b/client/views/creategameview.cpp
index ef990051..3a347c60 100644
--- a/client/views/creategameview.cpp
+++ b/client/views/creategameview.cpp
@@ -1,15 +1,10 @@
 #include "creategameview.h"
+#include "authdialog.h"
 #include "ui_creategameview.h"
 
 CreateGameView::CreateGameView(QWidget *parent)
     : QMainWindow(parent), ui(new Ui::CreateGameView) {
     ui->setupUi(this);
-    connect(ui->gamesListComboBox, SIGNAL(currentIndexChanged(int)), this,
-            SLOT(repeaterCurrentIndexChanged(int)));
-}
-
-void CreateGameView::repeaterCurrentIndexChanged(int index) {
-    emit currentIndexChanged(index);
 }
 
 CreateGameView::~CreateGameView() {
@@ -20,19 +15,13 @@ void CreateGameView::on_backButton_clicked() {
     this->close();
     emit shownStartView();
 }
-void CreateGameView::gotGamesListUpdate(
-    const std::vector<GameInfo> &newGamesList) {
-    for (const auto &gameInfo : newGamesList) {
-        ui->gamesListComboBox->addItem(gameInfo.display_name);
-    }
-}
-void CreateGameView::gotNewSelectedGame(const GameInfo &gameInfo) {
-    ui->gameNameLabel->setText(gameInfo.display_name);
-    ui->gameDescriptionTextBrowser->setText(gameInfo.description);
-    ui->playersAmountLabel->setText(QString::number(gameInfo.players_num));
-    ui->createGameButton->setEnabled(true);
-}
+
 void CreateGameView::on_createGameButton_clicked() {
-    //    this->close();
-    emit startedCreateGameRoutine(ui->gamesListComboBox->currentIndex());
+    if (!AuthDialog::verifyAuth(this)) {
+        return;
+    }
+    if (ui->roomNameEdit->text().isEmpty()) {
+        return;
+    }
+    emit startedCreateGameRoutine(ui->roomNameEdit->text());
 }
diff --git a/client/views/creategameview.h b/client/views/creategameview.h
index 23d84230..9f8ce258 100644
--- a/client/views/creategameview.h
+++ b/client/views/creategameview.h
@@ -2,7 +2,6 @@
 #define CAVOKE_CLIENT_CREATEGAMEVIEW_H
 
 #include <QMainWindow>
-#include "gameinfo.h"
 
 namespace Ui {
 class CreateGameView;
@@ -15,18 +14,13 @@ class CreateGameView : public QMainWindow {
     ~CreateGameView();
 
 public slots:
-    void gotGamesListUpdate(const std::vector<GameInfo> &newGamesList);
-    void gotNewSelectedGame(const GameInfo &gameInfo);
-
 signals:
     void shownStartView();
-    void currentIndexChanged(int index);
-    void startedCreateGameRoutine(int gameIndex);
+    void startedCreateGameRoutine(const QString &roomName);
 
 private slots:
     void on_backButton_clicked();
     void on_createGameButton_clicked();
-    void repeaterCurrentIndexChanged(int index);
 
 private:
     Ui::CreateGameView *ui;
diff --git a/client/views/creategameview.ui b/client/views/creategameview.ui
index 572d23bf..822dac4d 100644
--- a/client/views/creategameview.ui
+++ b/client/views/creategameview.ui
@@ -10,141 +10,196 @@
     <height>600</height>
    </rect>
   </property>
+  <property name="minimumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
   <property name="windowTitle">
-   <string>MainWindow</string>
+   <string>Cavoke</string>
   </property>
   <widget class="QWidget" name="centralwidget">
-   <widget class="QPushButton" name="backButton">
-    <property name="geometry">
-     <rect>
-      <x>40</x>
-      <y>480</y>
-      <width>90</width>
-      <height>32</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Back</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="label">
+   <widget class="QGroupBox" name="groupBox">
     <property name="geometry">
      <rect>
-      <x>280</x>
-      <y>60</y>
-      <width>181</width>
-      <height>71</height>
+      <x>9</x>
+      <y>9</y>
+      <width>782</width>
+      <height>541</height>
      </rect>
     </property>
-    <property name="font">
-     <font>
-      <pointsize>16</pointsize>
-     </font>
-    </property>
-    <property name="text">
-     <string>CREATE GAME</string>
-    </property>
-    <property name="scaledContents">
-     <bool>false</bool>
+    <property name="title">
+     <string/>
     </property>
     <property name="alignment">
      <set>Qt::AlignCenter</set>
     </property>
-   </widget>
-   <widget class="QComboBox" name="gamesListComboBox">
-    <property name="geometry">
-     <rect>
-      <x>220</x>
-      <y>190</y>
-      <width>291</width>
-      <height>41</height>
-     </rect>
-    </property>
-   </widget>
-   <widget class="QLabel" name="label_2">
-    <property name="geometry">
-     <rect>
-      <x>70</x>
-      <y>200</y>
-      <width>131</width>
-      <height>31</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Choose game to play</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="gameNameLabel">
-    <property name="geometry">
-     <rect>
-      <x>220</x>
-      <y>270</y>
-      <width>251</width>
-      <height>21</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Game name</string>
-    </property>
-   </widget>
-   <widget class="QTextBrowser" name="gameDescriptionTextBrowser">
-    <property name="geometry">
-     <rect>
-      <x>220</x>
-      <y>300</y>
-      <width>251</width>
-      <height>121</height>
-     </rect>
-    </property>
-    <property name="html">
-     <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
-&lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;meta charset=&quot;utf-8&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
-p, li { white-space: pre-wrap; }
-&lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'Sans Serif'; font-size:9pt; font-weight:400; font-style:normal;&quot;&gt;
-&lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;&lt;span style=&quot; font-family:'Cantarell'; font-size:10pt;&quot;&gt;Game description&lt;/span&gt;&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="label_3">
-    <property name="geometry">
-     <rect>
-      <x>520</x>
-      <y>280</y>
-      <width>111</width>
-      <height>21</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Players allowed:</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="playersAmountLabel">
-    <property name="geometry">
-     <rect>
-      <x>630</x>
-      <y>280</y>
-      <width>57</width>
-      <height>21</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>0</string>
-    </property>
-   </widget>
-   <widget class="QPushButton" name="createGameButton">
-    <property name="enabled">
-     <bool>false</bool>
-    </property>
-    <property name="geometry">
-     <rect>
-      <x>520</x>
-      <y>380</y>
-      <width>90</width>
-      <height>32</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Create game</string>
-    </property>
+    <widget class="QPushButton" name="backButton">
+     <property name="geometry">
+      <rect>
+       <x>1</x>
+       <y>4</y>
+       <width>61</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Minimum" vsizetype="Minimum">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="text">
+      <string>Back</string>
+     </property>
+     <property name="flat">
+      <bool>false</bool>
+     </property>
+    </widget>
+    <widget class="QWidget" name="gridLayoutWidget">
+     <property name="geometry">
+      <rect>
+       <x>59</x>
+       <y>30</y>
+       <width>661</width>
+       <height>481</height>
+      </rect>
+     </property>
+     <layout class="QGridLayout" name="gridLayout" rowstretch="4,2,2,2,3" columnstretch="1,3">
+      <property name="leftMargin">
+       <number>10</number>
+      </property>
+      <property name="rightMargin">
+       <number>10</number>
+      </property>
+      <item row="4" column="0" colspan="2">
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <property name="leftMargin">
+         <number>200</number>
+        </property>
+        <property name="topMargin">
+         <number>20</number>
+        </property>
+        <property name="rightMargin">
+         <number>200</number>
+        </property>
+        <property name="bottomMargin">
+         <number>20</number>
+        </property>
+        <item>
+         <widget class="QPushButton" name="createGameButton">
+          <property name="enabled">
+           <bool>true</bool>
+          </property>
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Minimum" vsizetype="Ignored">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Create room</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Room name:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="0" colspan="2">
+       <widget class="QLabel" name="label">
+        <property name="font">
+         <font>
+          <pointsize>16</pointsize>
+         </font>
+        </property>
+        <property name="text">
+         <string>CREATE ROOM</string>
+        </property>
+        <property name="scaledContents">
+         <bool>false</bool>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <layout class="QHBoxLayout" name="horizontalLayout_3">
+        <property name="leftMargin">
+         <number>10</number>
+        </property>
+        <property name="topMargin">
+         <number>10</number>
+        </property>
+        <property name="rightMargin">
+         <number>10</number>
+        </property>
+        <property name="bottomMargin">
+         <number>10</number>
+        </property>
+        <item>
+         <widget class="QLineEdit" name="roomNameEdit">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="font">
+           <font>
+            <pointsize>16</pointsize>
+           </font>
+          </property>
+          <property name="placeholderText">
+           <string>Room name</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item row="1" column="0" colspan="2">
+       <spacer name="verticalSpacer">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>40</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item row="3" column="0" colspan="2">
+       <spacer name="verticalSpacer_2">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>40</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+     </layout>
+    </widget>
+    <zorder>gridLayoutWidget</zorder>
+    <zorder>backButton</zorder>
    </widget>
   </widget>
   <widget class="QMenuBar" name="menubar">
@@ -153,7 +208,7 @@ p, li { white-space: pre-wrap; }
      <x>0</x>
      <y>0</y>
      <width>800</width>
-     <height>19</height>
+     <height>28</height>
     </rect>
    </property>
   </widget>
diff --git a/client/views/gameslistview.cpp b/client/views/gameslistview.cpp
index 5a371f9e..40498910 100644
--- a/client/views/gameslistview.cpp
+++ b/client/views/gameslistview.cpp
@@ -4,12 +4,17 @@
 GamesListView::GamesListView(QWidget *parent)
     : QMainWindow(parent), ui(new Ui::GamesListView) {
     ui->setupUi(this);
-    connect(ui->gamesListWidget, SIGNAL(currentRowChanged(int)), this,
+    connect(ui->gameNameComboBox, SIGNAL(currentIndexChanged(int)), this,
             SLOT(repeaterCurrentIndexChanged(int)));
 }
 
 void GamesListView::repeaterCurrentIndexChanged(int index) {
+    if (index == -1) {
+        displayEmpty();
+        return;
+    }
     emit currentIndexChanged(index);
+    emit requestGameStatistics(ui->gameNameComboBox->currentData().toString());
 }
 
 GamesListView::~GamesListView() {
@@ -22,19 +27,34 @@ void GamesListView::on_backButton_clicked() {
 }
 
 void GamesListView::on_downloadQmlButton_clicked() {
-    emit requestedDownloadGame(ui->gamesListWidget->currentRow());
+    emit requestedDownloadGame(ui->gameNameComboBox->currentIndex());
 }
 
 void GamesListView::gotGamesListUpdate(
     const std::vector<GameInfo> &newGamesList) {
+    ui->gameNameComboBox->clear();
     for (const auto &gameInfo : newGamesList) {
-        ui->gamesListWidget->addItem(gameInfo.display_name);
+        ui->gameNameComboBox->addItem(gameInfo.display_name, gameInfo.id);
     }
 }
 
 void GamesListView::gotNewSelectedGame(const GameInfo &gameInfo) {
-    ui->gameNameLabel->setText(gameInfo.display_name);
     ui->gameDescriptionTextBrowser->setText(gameInfo.description);
-    ui->playersAmountLabel->setText(QString::number(gameInfo.players_num));
-    //    ui->createGameButton->setEnabled(true);
+    ui->playersAllowedLabel->setText(QString::number(gameInfo.players_num));
+}
+
+void GamesListView::gotNewGameStatistics(const GameStatistics &gameStatistics) {
+    ui->averageDurationLabel->setText(
+        QString::number(gameStatistics.average_duration_sec));
+    ui->averagePlayersLabel->setText(
+        QString::number(gameStatistics.average_players_count));
+    ui->totalTimePlayedLabel->setText(
+        QString::number(gameStatistics.total_time_played_sec));
+    ui->totalGamesPlayedLabel->setText(
+        QString::number(gameStatistics.total_games_played));
+}
+
+void GamesListView::displayEmpty() {
+    ui->gameDescriptionTextBrowser->clear();
+    ui->playersAllowedLabel->clear();
 }
diff --git a/client/views/gameslistview.h b/client/views/gameslistview.h
index c9c54f3c..c4a22387 100644
--- a/client/views/gameslistview.h
+++ b/client/views/gameslistview.h
@@ -1,8 +1,9 @@
 #ifndef CAVOKE_GAMESLISTVIEW_H
 #define CAVOKE_GAMESLISTVIEW_H
 
-#include <gameinfo.h>
 #include <QMainWindow>
+#include "entities/gameinfo.h"
+#include "entities/gamestatistics.h"
 
 namespace Ui {
 class GamesListView;
@@ -17,10 +18,13 @@ class GamesListView : public QMainWindow {
 public slots:
     void gotGamesListUpdate(const std::vector<GameInfo> &newGamesList);
     void gotNewSelectedGame(const GameInfo &gameInfo);
+    void displayEmpty();
+    void gotNewGameStatistics(const GameStatistics &gameStatistics);
 
 signals:
     void shownStartView();
     void currentIndexChanged(int index);
+    void requestGameStatistics(const QString &gameId);
     void requestedDownloadGame(int index);
 
 private slots:
diff --git a/client/views/gameslistview.ui b/client/views/gameslistview.ui
index a079b4b3..d629c03a 100644
--- a/client/views/gameslistview.ui
+++ b/client/views/gameslistview.ui
@@ -10,120 +10,223 @@
     <height>600</height>
    </rect>
   </property>
+  <property name="minimumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
   <property name="windowTitle">
-   <string>MainWindow</string>
+   <string>Cavoke</string>
   </property>
   <widget class="QWidget" name="centralwidget">
-   <widget class="QPushButton" name="backButton">
-    <property name="geometry">
-     <rect>
-      <x>40</x>
-      <y>480</y>
-      <width>90</width>
-      <height>32</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Back</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="label">
-    <property name="geometry">
-     <rect>
-      <x>250</x>
-      <y>60</y>
-      <width>241</width>
-      <height>41</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>ALL AVAILABLE GAMES ON SERVER</string>
-    </property>
-    <property name="scaledContents">
-     <bool>false</bool>
-    </property>
-    <property name="alignment">
-     <set>Qt::AlignCenter</set>
-    </property>
-   </widget>
-   <widget class="QListWidget" name="gamesListWidget">
-    <property name="geometry">
-     <rect>
-      <x>145</x>
-      <y>121</y>
-      <width>371</width>
-      <height>321</height>
-     </rect>
-    </property>
-   </widget>
-   <widget class="QTextBrowser" name="gameDescriptionTextBrowser">
+   <widget class="QGroupBox" name="groupBox">
     <property name="geometry">
      <rect>
-      <x>540</x>
-      <y>210</y>
-      <width>251</width>
-      <height>121</height>
+      <x>9</x>
+      <y>9</y>
+      <width>782</width>
+      <height>541</height>
      </rect>
     </property>
-    <property name="html">
-     <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
+    <property name="title">
+     <string/>
+    </property>
+    <widget class="QPushButton" name="backButton">
+     <property name="geometry">
+      <rect>
+       <x>1</x>
+       <y>4</y>
+       <width>61</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Back</string>
+     </property>
+    </widget>
+    <widget class="QWidget" name="gridLayoutWidget">
+     <property name="geometry">
+      <rect>
+       <x>59</x>
+       <y>29</y>
+       <width>661</width>
+       <height>481</height>
+      </rect>
+     </property>
+     <layout class="QGridLayout" name="gridLayout" rowstretch="4,1,1,4,1,1,1,1,4" columnstretch="1,2">
+      <property name="leftMargin">
+       <number>10</number>
+      </property>
+      <property name="rightMargin">
+       <number>10</number>
+      </property>
+      <item row="1" column="1">
+       <widget class="QComboBox" name="gameNameComboBox">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+       </widget>
+      </item>
+      <item row="8" column="0" colspan="2">
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <property name="leftMargin">
+         <number>200</number>
+        </property>
+        <property name="topMargin">
+         <number>20</number>
+        </property>
+        <property name="rightMargin">
+         <number>200</number>
+        </property>
+        <property name="bottomMargin">
+         <number>20</number>
+        </property>
+        <item>
+         <widget class="QPushButton" name="downloadQmlButton">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Download QML</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_3">
+        <property name="text">
+         <string>Players allowed:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Game name:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="1">
+       <widget class="QTextBrowser" name="gameDescriptionTextBrowser">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="html">
+         <string>&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.0//EN&quot; &quot;http://www.w3.org/TR/REC-html40/strict.dtd&quot;&gt;
 &lt;html&gt;&lt;head&gt;&lt;meta name=&quot;qrichtext&quot; content=&quot;1&quot; /&gt;&lt;style type=&quot;text/css&quot;&gt;
 p, li { white-space: pre-wrap; }
 &lt;/style&gt;&lt;/head&gt;&lt;body style=&quot; font-family:'Cantarell'; font-size:10pt; font-weight:400; font-style:normal;&quot;&gt;
 &lt;p style=&quot; margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Game description&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="gameNameLabel">
-    <property name="geometry">
-     <rect>
-      <x>550</x>
-      <y>130</y>
-      <width>221</width>
-      <height>21</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Game name</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="label_3">
-    <property name="geometry">
-     <rect>
-      <x>550</x>
-      <y>170</y>
-      <width>111</width>
-      <height>21</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Players allowed:</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="playersAmountLabel">
-    <property name="geometry">
-     <rect>
-      <x>670</x>
-      <y>170</y>
-      <width>57</width>
-      <height>16</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>0</string>
-    </property>
-   </widget>
-   <widget class="QPushButton" name="downloadQmlButton">
-    <property name="geometry">
-     <rect>
-      <x>550</x>
-      <y>370</y>
-      <width>121</width>
-      <height>31</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Download QML</string>
-    </property>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QLabel" name="playersAllowedLabel">
+        <property name="text">
+         <string>0</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="0">
+       <widget class="QLabel" name="label_6">
+        <property name="text">
+         <string>Average duration, seconds:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="label_5">
+        <property name="text">
+         <string>Game description:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="5" column="0">
+       <widget class="QLabel" name="label_7">
+        <property name="text">
+         <string>Average players count:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="0" colspan="2">
+       <widget class="QLabel" name="label">
+        <property name="font">
+         <font>
+          <pointsize>16</pointsize>
+         </font>
+        </property>
+        <property name="layoutDirection">
+         <enum>Qt::LeftToRight</enum>
+        </property>
+        <property name="text">
+         <string>AVAILABLE GAMES ON SERVER</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="6" column="0">
+       <widget class="QLabel" name="label_8">
+        <property name="text">
+         <string>Total time played, seconds:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="7" column="0">
+       <widget class="QLabel" name="label_9">
+        <property name="text">
+         <string>Total games played:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="1">
+       <widget class="QLabel" name="averageDurationLabel">
+        <property name="text">
+         <string>0</string>
+        </property>
+       </widget>
+      </item>
+      <item row="5" column="1">
+       <widget class="QLabel" name="averagePlayersLabel">
+        <property name="text">
+         <string>0</string>
+        </property>
+       </widget>
+      </item>
+      <item row="6" column="1">
+       <widget class="QLabel" name="totalTimePlayedLabel">
+        <property name="text">
+         <string>0</string>
+        </property>
+       </widget>
+      </item>
+      <item row="7" column="1">
+       <widget class="QLabel" name="totalGamesPlayedLabel">
+        <property name="text">
+         <string>0</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
    </widget>
   </widget>
   <widget class="QMenuBar" name="menubar">
diff --git a/client/views/joingameview.cpp b/client/views/joingameview.cpp
index 7df5e378..c361855a 100644
--- a/client/views/joingameview.cpp
+++ b/client/views/joingameview.cpp
@@ -1,5 +1,5 @@
 #include "joingameview.h"
-#include <QFileDialog>
+#include "authdialog.h"
 #include "ui_joingameview.h"
 
 JoinGameView::JoinGameView(QWidget *parent)
@@ -18,6 +18,10 @@ void JoinGameView::on_backButton_clicked() {
 
 void JoinGameView::on_joinGameButton_clicked() {
     QString inviteCode = ui->inviteCodeInput->text();
+    // verify user is authenticated
+    if (!AuthDialog::verifyAuth(this)) {
+        return;
+    }
     if (!inviteCode.isEmpty()) {
         emit joinedGame(inviteCode);
     }
diff --git a/client/views/joingameview.ui b/client/views/joingameview.ui
index 608cdb33..27e7ab6a 100644
--- a/client/views/joingameview.ui
+++ b/client/views/joingameview.ui
@@ -10,86 +10,191 @@
     <height>600</height>
    </rect>
   </property>
+  <property name="minimumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
   <property name="windowTitle">
-   <string>MainWindow</string>
+   <string>Cavoke</string>
   </property>
   <widget class="QWidget" name="centralwidget">
-   <widget class="QPushButton" name="backButton">
+   <widget class="QGroupBox" name="groupBox">
     <property name="geometry">
      <rect>
-      <x>40</x>
-      <y>480</y>
-      <width>90</width>
-      <height>32</height>
+      <x>9</x>
+      <y>9</y>
+      <width>782</width>
+      <height>541</height>
      </rect>
     </property>
-    <property name="text">
-     <string>Back</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="label">
-    <property name="geometry">
-     <rect>
-      <x>240</x>
-      <y>60</y>
-      <width>291</width>
-      <height>71</height>
-     </rect>
-    </property>
-    <property name="font">
-     <font>
-      <pointsize>16</pointsize>
-     </font>
-    </property>
-    <property name="layoutDirection">
-     <enum>Qt::LeftToRight</enum>
-    </property>
-    <property name="text">
-     <string>JOIN GAME</string>
-    </property>
-    <property name="alignment">
-     <set>Qt::AlignCenter</set>
-    </property>
-   </widget>
-   <widget class="QPushButton" name="joinGameButton">
-    <property name="geometry">
-     <rect>
-      <x>440</x>
-      <y>180</y>
-      <width>121</width>
-      <height>41</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Join game</string>
-    </property>
-   </widget>
-   <widget class="QLineEdit" name="inviteCodeInput">
-    <property name="geometry">
-     <rect>
-      <x>140</x>
-      <y>170</y>
-      <width>261</width>
-      <height>61</height>
-     </rect>
-    </property>
-    <property name="font">
-     <font>
-      <pointsize>16</pointsize>
-     </font>
-    </property>
-    <property name="statusTip">
-     <string/>
-    </property>
-    <property name="whatsThis">
-     <string/>
-    </property>
-    <property name="text">
+    <property name="title">
      <string/>
     </property>
-    <property name="placeholderText">
-     <string>Invite code</string>
-    </property>
+    <widget class="QPushButton" name="backButton">
+     <property name="geometry">
+      <rect>
+       <x>1</x>
+       <y>4</y>
+       <width>61</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Back</string>
+     </property>
+    </widget>
+    <widget class="QWidget" name="gridLayoutWidget">
+     <property name="geometry">
+      <rect>
+       <x>59</x>
+       <y>29</y>
+       <width>661</width>
+       <height>481</height>
+      </rect>
+     </property>
+     <layout class="QGridLayout" name="gridLayout" rowstretch="4,2,2,2,3" columnstretch="1,3">
+      <property name="leftMargin">
+       <number>10</number>
+      </property>
+      <property name="rightMargin">
+       <number>10</number>
+      </property>
+      <item row="2" column="1">
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <property name="leftMargin">
+         <number>10</number>
+        </property>
+        <property name="topMargin">
+         <number>10</number>
+        </property>
+        <property name="rightMargin">
+         <number>10</number>
+        </property>
+        <property name="bottomMargin">
+         <number>10</number>
+        </property>
+        <item>
+         <widget class="QLineEdit" name="inviteCodeInput">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="font">
+           <font>
+            <pointsize>16</pointsize>
+           </font>
+          </property>
+          <property name="statusTip">
+           <string/>
+          </property>
+          <property name="whatsThis">
+           <string/>
+          </property>
+          <property name="text">
+           <string/>
+          </property>
+          <property name="placeholderText">
+           <string>Invite code</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Invite code:</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0" colspan="2">
+       <spacer name="verticalSpacer">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>40</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item row="4" column="0" colspan="2">
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <property name="leftMargin">
+         <number>200</number>
+        </property>
+        <property name="topMargin">
+         <number>20</number>
+        </property>
+        <property name="rightMargin">
+         <number>200</number>
+        </property>
+        <property name="bottomMargin">
+         <number>20</number>
+        </property>
+        <item>
+         <widget class="QPushButton" name="joinGameButton">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Join room</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item row="0" column="0" colspan="2">
+       <widget class="QLabel" name="label">
+        <property name="font">
+         <font>
+          <pointsize>16</pointsize>
+         </font>
+        </property>
+        <property name="layoutDirection">
+         <enum>Qt::LeftToRight</enum>
+        </property>
+        <property name="text">
+         <string>JOIN ROOM</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0" colspan="2">
+       <spacer name="verticalSpacer_2">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>40</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+     </layout>
+    </widget>
    </widget>
   </widget>
   <widget class="QMenuBar" name="menubar">
@@ -98,7 +203,7 @@
      <x>0</x>
      <y>0</y>
      <width>800</width>
-     <height>19</height>
+     <height>28</height>
     </rect>
    </property>
   </widget>
diff --git a/client/views/protoroomview.cpp b/client/views/protoroomview.cpp
deleted file mode 100644
index 8d7d12c3..00000000
--- a/client/views/protoroomview.cpp
+++ /dev/null
@@ -1,51 +0,0 @@
-#include "protoroomview.h"
-#include "ui_protoroomview.h"
-
-ProtoRoomView::ProtoRoomView(QWidget *parent)
-    : QMainWindow(parent), ui(new Ui::ProtoRoomView) {
-    ui->setupUi(this);
-}
-
-ProtoRoomView::~ProtoRoomView() {
-    delete ui;
-}
-
-void ProtoRoomView::updateStatus(CreatingGameStatus newStatus) {
-    ui->statusLabel->setText(STATUS.at(newStatus));
-    ui->joinGameButton->setEnabled(newStatus == CreatingGameStatus::DONE);
-}
-
-void ProtoRoomView::updateInviteCode(const QString &newInviteCode) {
-    ui->inviteCodeLabel->setText(newInviteCode);
-}
-
-void ProtoRoomView::on_joinGameButton_clicked() {
-    this->close();
-    emit joinedCreatedGame(gameName);
-}
-void ProtoRoomView::updateGameName(const QString &name) {
-    gameName = name;
-    ui->gameNameLabel->setText(gameName);
-}
-void ProtoRoomView::prepareJoinCreate(bool _isJoining) {
-    isJoining = _isJoining;
-    if (isJoining) {
-        ui->headerLabel->setText("Joining game session");
-        ui->gameNameHLabel->show();
-        ui->gameNameLabel->show();
-        ui->inviteCodeHLabel->hide();
-        ui->inviteCodeLabel->hide();
-    } else {
-        ui->headerLabel->setText("Creating game session");
-        ui->gameNameHLabel->hide();
-        ui->gameNameLabel->hide();
-        ui->inviteCodeHLabel->show();
-        ui->inviteCodeLabel->show();
-    }
-    updateInviteCode("");
-}
-
-void ProtoRoomView::on_backButton_clicked() {
-    this->close();
-    emit shownStartView();
-}
diff --git a/client/views/protoroomview.h b/client/views/protoroomview.h
deleted file mode 100644
index a7cf5d29..00000000
--- a/client/views/protoroomview.h
+++ /dev/null
@@ -1,43 +0,0 @@
-#ifndef CAVOKE_CLIENT_MIDDLESCREENVIEW_H
-#define CAVOKE_CLIENT_MIDDLESCREENVIEW_H
-
-#include <QMainWindow>
-
-namespace Ui {
-class ProtoRoomView;
-}
-
-class ProtoRoomView : public QMainWindow {
-    Q_OBJECT
-public:
-    enum class CreatingGameStatus { UNKNOWN, DOWNLOAD, REQUESTED, DONE };
-    explicit ProtoRoomView(QWidget *parent = nullptr);
-    ~ProtoRoomView();
-
-public slots:
-    void updateStatus(CreatingGameStatus newStatus);
-    void updateInviteCode(const QString &newInviteCode);
-    void updateGameName(const QString &name);
-    void prepareJoinCreate(bool _isJoining);
-
-signals:
-    void joinedCreatedGame(const QString &appName);
-    void shownStartView();
-
-private slots:
-    void on_joinGameButton_clicked();
-    void on_backButton_clicked();
-
-private:
-    Ui::ProtoRoomView *ui;
-    const std::map<CreatingGameStatus, QString> STATUS = {
-        {CreatingGameStatus::UNKNOWN, "Unknown"},
-        {CreatingGameStatus::DOWNLOAD, "Downloading"},
-        {CreatingGameStatus::REQUESTED, "Sending request"},
-        {CreatingGameStatus::DONE, "Done"},
-    };
-    QString gameName;
-    bool isJoining = false;
-};
-
-#endif  // CAVOKE_CLIENT_MIDDLESCREENVIEW_H
diff --git a/client/views/protoroomview.ui b/client/views/protoroomview.ui
deleted file mode 100644
index 3804fe69..00000000
--- a/client/views/protoroomview.ui
+++ /dev/null
@@ -1,179 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>ProtoRoomView</class>
- <widget class="QMainWindow" name="ProtoRoomView">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>800</width>
-    <height>600</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>MainWindow</string>
-  </property>
-  <widget class="QWidget" name="centralwidget">
-   <widget class="QLabel" name="statusLabel">
-    <property name="geometry">
-     <rect>
-      <x>180</x>
-      <y>110</y>
-      <width>231</width>
-      <height>61</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Unknown</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="headerLabel">
-    <property name="geometry">
-     <rect>
-      <x>220</x>
-      <y>20</y>
-      <width>251</width>
-      <height>81</height>
-     </rect>
-    </property>
-    <property name="font">
-     <font>
-      <pointsize>16</pointsize>
-     </font>
-    </property>
-    <property name="text">
-     <string>Creating game session</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="label_2">
-    <property name="geometry">
-     <rect>
-      <x>50</x>
-      <y>130</y>
-      <width>121</width>
-      <height>21</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Current status:</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="inviteCodeHLabel">
-    <property name="geometry">
-     <rect>
-      <x>50</x>
-      <y>240</y>
-      <width>91</width>
-      <height>16</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Invite code:</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="inviteCodeLabel">
-    <property name="geometry">
-     <rect>
-      <x>180</x>
-      <y>220</y>
-      <width>231</width>
-      <height>51</height>
-     </rect>
-    </property>
-    <property name="font">
-     <font>
-      <pointsize>14</pointsize>
-     </font>
-    </property>
-    <property name="mouseTracking">
-     <bool>false</bool>
-    </property>
-    <property name="acceptDrops">
-     <bool>false</bool>
-    </property>
-    <property name="text">
-     <string>Unknown</string>
-    </property>
-    <property name="textInteractionFlags">
-     <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByMouse</set>
-    </property>
-   </widget>
-   <widget class="QPushButton" name="joinGameButton">
-    <property name="enabled">
-     <bool>false</bool>
-    </property>
-    <property name="geometry">
-     <rect>
-      <x>290</x>
-      <y>350</y>
-      <width>90</width>
-      <height>32</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Join game</string>
-    </property>
-    <property name="checkable">
-     <bool>false</bool>
-    </property>
-   </widget>
-   <widget class="QLabel" name="gameNameLabel">
-    <property name="geometry">
-     <rect>
-      <x>180</x>
-      <y>170</y>
-      <width>231</width>
-      <height>51</height>
-     </rect>
-    </property>
-    <property name="font">
-     <font>
-      <pointsize>14</pointsize>
-     </font>
-    </property>
-    <property name="text">
-     <string>Unknown</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="gameNameHLabel">
-    <property name="geometry">
-     <rect>
-      <x>50</x>
-      <y>190</y>
-      <width>91</width>
-      <height>16</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Game name:</string>
-    </property>
-   </widget>
-   <widget class="QPushButton" name="backButton">
-    <property name="geometry">
-     <rect>
-      <x>60</x>
-      <y>480</y>
-      <width>90</width>
-      <height>32</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Back</string>
-    </property>
-   </widget>
-  </widget>
-  <widget class="QMenuBar" name="menubar">
-   <property name="geometry">
-    <rect>
-     <x>0</x>
-     <y>0</y>
-     <width>800</width>
-     <height>19</height>
-    </rect>
-   </property>
-  </widget>
-  <widget class="QStatusBar" name="statusbar"/>
- </widget>
- <resources/>
- <connections/>
-</ui>
diff --git a/client/views/roomview.cpp b/client/views/roomview.cpp
new file mode 100644
index 00000000..3f7f61b2
--- /dev/null
+++ b/client/views/roomview.cpp
@@ -0,0 +1,102 @@
+#include "roomview.h"
+#include "ui_roomview.h"
+
+RoomView::RoomView(QWidget *parent)
+    : QMainWindow(parent), ui(new Ui::RoomView) {
+    ui->setupUi(this);
+}
+
+RoomView::~RoomView() {
+    delete ui;
+}
+
+void RoomView::updateStatus(CreatingSessionStatus newStatus) {
+    status = newStatus;
+    ui->waitForHostLabel->setText(STATUS.at(status));
+    ui->joinSessionButton->setEnabled(status ==
+                                      CreatingSessionStatus::NOW_YOU_CAN_JOIN);
+}
+
+void RoomView::updateRoomInfo(const RoomInfo &roomInfo) {
+    sessionId = roomInfo.session_id;
+    is_host = roomInfo.isHost;
+    ui->roomNameLabel->setText(roomInfo.display_name);
+    ui->inviteCodeLabel->setText(roomInfo.invite_code);
+    ui->membersListWidget->clear();
+    for (const auto &member : roomInfo.members) {
+        ui->membersListWidget->addItem(member.display_name);
+    }
+
+    if (!sessionId.isEmpty()) {
+        requestedSessionUpdate(sessionId);
+    } else {
+        updateSessionInfo(SessionInfo());
+    }
+}
+
+void RoomView::updateSessionInfo(const SessionInfo &sessionInfo) {
+    if (!is_host) {
+        ui->sessionGameLabel->hide();
+        ui->sessionGameComboBox->hide();
+        ui->createSessionButton->hide();
+        ui->joinSessionButton->show();
+        ui->joinSessionButton->setEnabled(sessionInfo.status !=
+                                          SessionInfo::Status::FINISHED);
+        updateStatus(sessionInfo.status != SessionInfo::Status::FINISHED
+                         ? CreatingSessionStatus::NOW_YOU_CAN_JOIN
+                         : CreatingSessionStatus::WAIT_FOR_THE_HOST);
+        return;
+    }
+    if (sessionInfo.status != SessionInfo::Status::FINISHED) {
+        ui->createSessionButton->hide();
+        ui->joinSessionButton->show();
+        ui->joinSessionButton->setEnabled(true);
+        ui->sessionGameLabel->hide();
+        ui->sessionGameComboBox->hide();
+        updateStatus(CreatingSessionStatus::NOW_YOU_CAN_JOIN);
+    } else {
+        ui->createSessionButton->show();
+        ui->joinSessionButton->hide();
+        ui->createSessionButton->setEnabled(true);
+        ui->sessionGameLabel->show();
+        ui->sessionGameComboBox->show();
+        updateStatus(CreatingSessionStatus::YOU_CAN_CREATE);
+    }
+}
+
+void RoomView::gotGamesListUpdate(const std::vector<GameInfo> &newGamesList) {
+    ui->sessionGameComboBox->clear();
+    for (const auto &gameInfo : newGamesList) {
+        ui->sessionGameComboBox->addItem(gameInfo.display_name, gameInfo.id);
+    }
+    if (ui->sessionGameComboBox->count() > 0) {
+        ui->sessionGameComboBox->setCurrentIndex(0);
+    } else {
+        ui->sessionGameComboBox->setCurrentIndex(-1);
+    }
+}
+
+void RoomView::clear() {
+    updateStatus(CreatingSessionStatus::UNKNOWN);
+    ui->roomNameLabel->setText("<room_name>");
+    ui->inviteCodeLabel->setText("<invite_code>");
+    ui->membersListWidget->clear();
+}
+
+void RoomView::on_backButton_clicked() {
+    this->clear();
+    this->close();
+    emit leftRoom();
+    emit shownStartView();
+}
+
+void RoomView::on_joinSessionButton_clicked() {
+    emit joinedSession(sessionId);
+}
+
+void RoomView::on_createSessionButton_clicked() {
+    if (ui->sessionGameComboBox->currentData().toString().isEmpty()) {
+        return;  // Probably no games at all
+    }
+    emit createdSession(ui->sessionGameComboBox->currentData().toString());
+}
diff --git a/client/views/roomview.h b/client/views/roomview.h
new file mode 100644
index 00000000..08000e82
--- /dev/null
+++ b/client/views/roomview.h
@@ -0,0 +1,61 @@
+#ifndef CAVOKE_CLIENT_ROOMVIEW_H
+#define CAVOKE_CLIENT_ROOMVIEW_H
+
+#include <QMainWindow>
+#include "entities/gameinfo.h"
+#include "entities/role.h"
+#include "entities/roominfo.h"
+#include "entities/sessioninfo.h"
+#include "entities/validationresult.h"
+
+namespace Ui {
+class RoomView;
+}
+
+class RoomView : public QMainWindow {
+    Q_OBJECT
+public:
+    enum class CreatingSessionStatus {
+        UNKNOWN,
+        WAIT_FOR_THE_HOST,
+        NOW_YOU_CAN_JOIN,
+        YOU_CAN_CREATE
+    };
+    explicit RoomView(QWidget *parent = nullptr);
+    ~RoomView();
+
+public slots:
+    void updateRoomInfo(const RoomInfo &roomInfo);
+    void updateSessionInfo(const SessionInfo &sessionInfo);  // Temporary
+    void clear();
+    void gotGamesListUpdate(const std::vector<GameInfo> &newGamesList);
+
+signals:
+    void createdSession(const QString &gameId);
+    void joinedSession(const QString &sessionId);
+    void requestedSessionUpdate(const QString &sessionId);
+    void shownStartView();
+    void leftRoom();
+
+private slots:
+    void updateStatus(CreatingSessionStatus newStatus);
+    void on_backButton_clicked();
+    void on_joinSessionButton_clicked();
+    void on_createSessionButton_clicked();
+
+private:
+    Ui::RoomView *ui;
+    const std::map<CreatingSessionStatus, QString> STATUS = {
+        {CreatingSessionStatus::UNKNOWN, "Unknown"},
+        {CreatingSessionStatus::WAIT_FOR_THE_HOST,
+         "Wait for the host to create a session"},
+        {CreatingSessionStatus::NOW_YOU_CAN_JOIN,
+         "Now you can join the session!"},
+        {CreatingSessionStatus::YOU_CAN_CREATE, "You can create a session"},
+    };
+    QString sessionId;
+    CreatingSessionStatus status = CreatingSessionStatus::UNKNOWN;
+    bool is_host = false;  // Wow, this is very cool
+};
+
+#endif  // CAVOKE_CLIENT_ROOMVIEW_H
diff --git a/client/views/roomview.ui b/client/views/roomview.ui
new file mode 100644
index 00000000..aaa658ec
--- /dev/null
+++ b/client/views/roomview.ui
@@ -0,0 +1,234 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>RoomView</class>
+ <widget class="QMainWindow" name="RoomView">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>600</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Cavoke</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <widget class="QGroupBox" name="groupBox">
+    <property name="geometry">
+     <rect>
+      <x>9</x>
+      <y>9</y>
+      <width>782</width>
+      <height>541</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string/>
+    </property>
+    <widget class="QPushButton" name="backButton">
+     <property name="geometry">
+      <rect>
+       <x>1</x>
+       <y>4</y>
+       <width>61</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Leave</string>
+     </property>
+    </widget>
+    <widget class="QWidget" name="gridLayoutWidget">
+     <property name="geometry">
+      <rect>
+       <x>59</x>
+       <y>29</y>
+       <width>661</width>
+       <height>481</height>
+      </rect>
+     </property>
+     <layout class="QGridLayout" name="gridLayout" rowstretch="2,1,1,1,1,1,1,1,3" columnstretch="1,2">
+      <property name="leftMargin">
+       <number>10</number>
+      </property>
+      <property name="rightMargin">
+       <number>10</number>
+      </property>
+      <item row="3" column="1">
+       <widget class="QLabel" name="inviteCodeLabel">
+        <property name="font">
+         <font>
+          <pointsize>14</pointsize>
+         </font>
+        </property>
+        <property name="mouseTracking">
+         <bool>true</bool>
+        </property>
+        <property name="acceptDrops">
+         <bool>false</bool>
+        </property>
+        <property name="text">
+         <string>&lt;invite_code&gt;</string>
+        </property>
+        <property name="textInteractionFlags">
+         <set>Qt::LinksAccessibleByMouse|Qt::TextSelectableByMouse</set>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="1" rowspan="2">
+       <widget class="QListWidget" name="membersListWidget"/>
+      </item>
+      <item row="8" column="0" colspan="2">
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <property name="leftMargin">
+         <number>200</number>
+        </property>
+        <property name="topMargin">
+         <number>20</number>
+        </property>
+        <property name="rightMargin">
+         <number>200</number>
+        </property>
+        <property name="bottomMargin">
+         <number>20</number>
+        </property>
+        <item>
+         <widget class="QPushButton" name="joinSessionButton">
+          <property name="enabled">
+           <bool>false</bool>
+          </property>
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Join session</string>
+          </property>
+          <property name="checkable">
+           <bool>false</bool>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="createSessionButton">
+          <property name="enabled">
+           <bool>true</bool>
+          </property>
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Create session</string>
+          </property>
+          <property name="checkable">
+           <bool>false</bool>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="inviteCodeHLabel">
+        <property name="text">
+         <string>Invite code:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="6" column="0" colspan="2">
+       <widget class="QLabel" name="waitForHostLabel">
+        <property name="text">
+         <string>Wait for the host to create a session</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="0" rowspan="2" colspan="2">
+       <widget class="QLabel" name="headerLabel">
+        <property name="font">
+         <font>
+          <pointsize>16</pointsize>
+         </font>
+        </property>
+        <property name="text">
+         <string>WAITING ROOM</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="0">
+       <widget class="QLabel" name="currentMembersHLabel">
+        <property name="text">
+         <string>Current members:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="roomNameHLabel">
+        <property name="text">
+         <string>Room name:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="7" column="1">
+       <widget class="QComboBox" name="sessionGameComboBox"/>
+      </item>
+      <item row="7" column="0">
+       <widget class="QLabel" name="sessionGameLabel">
+        <property name="text">
+         <string>Choose session game:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QLabel" name="roomNameLabel">
+        <property name="font">
+         <font>
+          <pointsize>14</pointsize>
+         </font>
+        </property>
+        <property name="text">
+         <string>&lt;room_name&gt;</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </widget>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>800</width>
+     <height>28</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/client/views/sessionview.cpp b/client/views/sessionview.cpp
new file mode 100644
index 00000000..c8d526b1
--- /dev/null
+++ b/client/views/sessionview.cpp
@@ -0,0 +1,99 @@
+#include "sessionview.h"
+#include "ui_sessionview.h"
+
+SessionView::SessionView(QWidget *parent)
+    : QMainWindow(parent), ui(new Ui::SessionView) {
+    ui->setupUi(this);
+    connect(ui->roleComboBox, SIGNAL(currentIndexChanged(int)), this,
+            SLOT(repeaterCurrentIndexChanged(int)));
+}
+
+SessionView::~SessionView() {
+    delete ui;
+}
+
+void SessionView::repeaterCurrentIndexChanged(int index) {
+    if (index == -1 || ui->roleComboBox->itemData(index).toInt() == ourRole) {
+        //        displayEmpty();
+        return;
+    }
+    //    qDebug() << "Chosen: " << ui->roleComboBox->itemText(index);
+    qDebug() << "Got new role index: "
+             << ui->roleComboBox->itemData(index).toInt();
+    emit newRoleChosen(ui->roleComboBox->itemData(index).toInt());
+}
+
+void SessionView::updateStatus(CreatingGameStatus newStatus) {
+    ui->statusLabel->setText(STATUS.at(newStatus));
+    ui->currentPlayersHLabel->setHidden(newStatus != CreatingGameStatus::DONE);
+    ui->playersListWidget->setHidden(newStatus != CreatingGameStatus::DONE);
+}
+
+void SessionView::updateSessionInfo(const SessionInfo &sessionInfo) {
+    ui->playersListWidget->clear();
+    for (const auto &player : sessionInfo.players) {
+        ui->playersListWidget->addItem(player.user.display_name);
+    }
+    if (sessionInfo.isHost) {
+        show_as_host();
+    } else {
+        show_as_guest();
+    }
+    if (sessionInfo.status == SessionInfo::Status::RUNNING) {
+        this->close();
+        emit joinedCreatedGame();
+    }
+}
+
+void SessionView::updateValidationResult(
+    const ValidationResult &validationResult) {
+    ui->startGameButton->setEnabled(validationResult.success);
+    ui->joinErrorLabel->setText(validationResult.message);
+}
+
+void SessionView::on_startGameButton_clicked() {
+    emit createdGame();
+}
+
+void SessionView::clear() {
+    ui->currentPlayersHLabel->hide();
+    ui->playersListWidget->hide();
+
+    ui->gameNameLabel->setText("Unknown");
+}
+
+void SessionView::on_backButton_clicked() {
+    this->clear();
+    this->close();
+    qDebug() << "Pressed Back From Session";
+    emit leftSession();
+    emit shownRoomView();
+}
+void SessionView::updateGameName(const QString &gameName) {
+    ui->gameNameLabel->setText(gameName);
+}
+void SessionView::gotRolesListUpdate(const std::vector<Role> &newRolesList) {
+    // Some bad way to check whether list actually updated
+    // TODO: implement it
+
+    ourRole = newRolesList.front().id;
+    ui->roleComboBox->clear();
+    for (const auto &roleIdAndName : newRolesList) {
+        ui->roleComboBox->addItem(roleIdAndName.name, roleIdAndName.id);
+    }
+    if (ui->roleComboBox->count() > 0) {
+        ui->roleComboBox->setCurrentIndex(0);
+    } else {
+        ui->roleComboBox->setCurrentIndex(-1);
+    }
+}
+void SessionView::show_as_host() {
+    ui->waitForHostLabel->hide();
+    ui->joinErrorLabel->show();
+    ui->startGameButton->show();
+}
+void SessionView::show_as_guest() {
+    ui->waitForHostLabel->show();
+    ui->joinErrorLabel->hide();
+    ui->startGameButton->hide();
+}
diff --git a/client/views/sessionview.h b/client/views/sessionview.h
new file mode 100644
index 00000000..42b10d47
--- /dev/null
+++ b/client/views/sessionview.h
@@ -0,0 +1,53 @@
+#ifndef CAVOKE_CLIENT_SESSIONVIEW_H
+#define CAVOKE_CLIENT_SESSIONVIEW_H
+
+#include <QMainWindow>
+#include "entities/role.h"
+#include "entities/sessioninfo.h"
+#include "entities/validationresult.h"
+
+namespace Ui {
+class SessionView;
+}
+
+class SessionView : public QMainWindow {
+    Q_OBJECT
+public:
+    enum class CreatingGameStatus { UNKNOWN, DOWNLOAD, REQUESTED, DONE };
+    explicit SessionView(QWidget *parent = nullptr);
+    ~SessionView();
+
+public slots:
+    void updateStatus(CreatingGameStatus newStatus);
+    void updateSessionInfo(const SessionInfo &sessionInfo);
+    void clear();
+    void updateValidationResult(const ValidationResult &validationResult);
+    void updateGameName(const QString &gameName);
+    void gotRolesListUpdate(const std::vector<Role> &newRolesList);
+
+signals:
+    void createdGame();
+    void joinedCreatedGame();
+    void shownRoomView();
+    void leftSession();
+    void newRoleChosen(int roleId);
+
+private slots:
+    void on_startGameButton_clicked();
+    void on_backButton_clicked();
+    void repeaterCurrentIndexChanged(int index);
+
+private:
+    Ui::SessionView *ui;
+    void show_as_host();
+    void show_as_guest();
+    const std::map<CreatingGameStatus, QString> STATUS = {
+        {CreatingGameStatus::UNKNOWN, "Unknown"},
+        {CreatingGameStatus::DOWNLOAD, "Downloading"},
+        {CreatingGameStatus::REQUESTED, "Sending request"},
+        {CreatingGameStatus::DONE, "Ready"},
+    };
+    int ourRole = -1;
+};
+
+#endif  // CAVOKE_CLIENT_SESSIONVIEW_H
diff --git a/client/views/sessionview.ui b/client/views/sessionview.ui
new file mode 100644
index 00000000..cb0daebc
--- /dev/null
+++ b/client/views/sessionview.ui
@@ -0,0 +1,213 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>SessionView</class>
+ <widget class="QMainWindow" name="SessionView">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>600</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Cavoke</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <widget class="QGroupBox" name="groupBox">
+    <property name="geometry">
+     <rect>
+      <x>9</x>
+      <y>9</y>
+      <width>782</width>
+      <height>541</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string/>
+    </property>
+    <widget class="QPushButton" name="backButton">
+     <property name="geometry">
+      <rect>
+       <x>1</x>
+       <y>4</y>
+       <width>61</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Leave</string>
+     </property>
+    </widget>
+    <widget class="QWidget" name="gridLayoutWidget">
+     <property name="geometry">
+      <rect>
+       <x>59</x>
+       <y>29</y>
+       <width>661</width>
+       <height>481</height>
+      </rect>
+     </property>
+     <layout class="QGridLayout" name="gridLayout" rowstretch="2,1,1,1,1,1,1,1,1,3" columnstretch="1,2">
+      <property name="leftMargin">
+       <number>10</number>
+      </property>
+      <property name="rightMargin">
+       <number>10</number>
+      </property>
+      <item row="5" column="1" rowspan="2">
+       <widget class="QListWidget" name="playersListWidget"/>
+      </item>
+      <item row="0" column="0" rowspan="2" colspan="2">
+       <widget class="QLabel" name="headerLabel">
+        <property name="font">
+         <font>
+          <pointsize>16</pointsize>
+         </font>
+        </property>
+        <property name="text">
+         <string>SESSION ROOM</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="7" column="1">
+       <widget class="QComboBox" name="roleComboBox"/>
+      </item>
+      <item row="8" column="0" colspan="2">
+       <widget class="QLabel" name="waitForHostLabel">
+        <property name="text">
+         <string>Wait for the host to launch the game</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="1">
+       <widget class="QLabel" name="joinErrorLabel">
+        <property name="text">
+         <string/>
+        </property>
+       </widget>
+      </item>
+      <item row="5" column="0">
+       <widget class="QLabel" name="currentPlayersHLabel">
+        <property name="text">
+         <string>Current players:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="9" column="0" colspan="2">
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <property name="leftMargin">
+         <number>200</number>
+        </property>
+        <property name="topMargin">
+         <number>20</number>
+        </property>
+        <property name="rightMargin">
+         <number>200</number>
+        </property>
+        <property name="bottomMargin">
+         <number>20</number>
+        </property>
+        <item>
+         <widget class="QPushButton" name="startGameButton">
+          <property name="enabled">
+           <bool>false</bool>
+          </property>
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Start game</string>
+          </property>
+          <property name="checkable">
+           <bool>false</bool>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Current status:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="7" column="0">
+       <widget class="QLabel" name="playerRoleLabel">
+        <property name="text">
+         <string>Your role:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="gameNameHLabel">
+        <property name="text">
+         <string>Game name:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="1">
+       <widget class="QLabel" name="gameNameLabel">
+        <property name="font">
+         <font>
+          <pointsize>14</pointsize>
+         </font>
+        </property>
+        <property name="text">
+         <string>&lt;game_name&gt;</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QLabel" name="statusLabel">
+        <property name="font">
+         <font>
+          <pointsize>14</pointsize>
+         </font>
+        </property>
+        <property name="text">
+         <string>&lt;session_status&gt;</string>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </widget>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>800</width>
+     <height>28</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/client/views/settingsview.cpp b/client/views/settingsview.cpp
index 0044163e..71830a1a 100644
--- a/client/views/settingsview.cpp
+++ b/client/views/settingsview.cpp
@@ -1,4 +1,5 @@
 #include "settingsview.h"
+#include "AuthenticationManager.h"
 #include "ui_settingsview.h"
 
 SettingsView::SettingsView(QWidget *parent)
@@ -10,7 +11,33 @@ SettingsView::~SettingsView() {
     delete ui;
 }
 
+void SettingsView::initStartValues(const QString &displayName,
+                                   const QString &host) {
+    ui->nicknameInput->setText(displayName);
+    oldDisplayName = displayName;
+    ui->serverAddressInput->setText(host);
+}
+
+void SettingsView::updateDisplayName(const QString &displayName) {
+    ui->nicknameInput->setText(displayName);
+    oldDisplayName = displayName;
+}
+
 void SettingsView::on_backButton_clicked() {
     this->close();
     emit shownStartView();
 }
+void SettingsView::on_updateSettingsButton_clicked() {
+    if (ui->nicknameInput->text() != oldDisplayName) {
+        if (!AuthDialog::verifyAuth(this)) {
+            return;
+        }
+    }
+    emit updatedSettings(ui->nicknameInput->text(),
+                         ui->serverAddressInput->text());
+    this->close();
+    emit shownStartView();
+}
+void SettingsView::on_reloginButton_clicked() {
+    cavoke::auth::AuthenticationManager::getInstance().relogin();
+}
diff --git a/client/views/settingsview.h b/client/views/settingsview.h
index 74130d7b..dd3133b9 100644
--- a/client/views/settingsview.h
+++ b/client/views/settingsview.h
@@ -2,6 +2,7 @@
 #define CAVOKE_CLIENT_SETTINGSVIEW_H
 
 #include <QMainWindow>
+#include "authdialog.h"
 
 namespace Ui {
 class SettingsView;
@@ -13,14 +14,22 @@ class SettingsView : public QMainWindow {
     explicit SettingsView(QWidget *parent = nullptr);
     ~SettingsView();
 
+public slots:
+    void initStartValues(const QString &displayName, const QString &host);
+    void updateDisplayName(const QString &displayName);
+
 signals:
     void shownStartView();
+    void updatedSettings(const QString &displayName, const QString &host);
 
 private slots:
     void on_backButton_clicked();
+    void on_updateSettingsButton_clicked();
+    void on_reloginButton_clicked();
 
 private:
     Ui::SettingsView *ui;
+    QString oldDisplayName{};
 };
 
 #endif  // CAVOKE_CLIENT_SETTINGSVIEW_H
diff --git a/client/views/settingsview.ui b/client/views/settingsview.ui
index 5a71a931..9414bfae 100644
--- a/client/views/settingsview.ui
+++ b/client/views/settingsview.ui
@@ -10,35 +10,180 @@
     <height>600</height>
    </rect>
   </property>
+  <property name="minimumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
   <property name="windowTitle">
-   <string>MainWindow</string>
+   <string>Cavoke</string>
   </property>
   <widget class="QWidget" name="centralwidget">
-   <widget class="QPushButton" name="backButton">
-    <property name="geometry">
-     <rect>
-      <x>40</x>
-      <y>480</y>
-      <width>90</width>
-      <height>32</height>
-     </rect>
-    </property>
-    <property name="text">
-     <string>Back</string>
-    </property>
-   </widget>
-   <widget class="QLabel" name="label">
+   <widget class="QGroupBox" name="groupBox">
     <property name="geometry">
      <rect>
-      <x>200</x>
-      <y>60</y>
-      <width>291</width>
-      <height>71</height>
+      <x>9</x>
+      <y>9</y>
+      <width>782</width>
+      <height>541</height>
      </rect>
     </property>
-    <property name="text">
-     <string>Settings. Empty.</string>
+    <property name="title">
+     <string/>
     </property>
+    <widget class="QPushButton" name="backButton">
+     <property name="geometry">
+      <rect>
+       <x>1</x>
+       <y>4</y>
+       <width>61</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Back</string>
+     </property>
+    </widget>
+    <widget class="QWidget" name="gridLayoutWidget">
+     <property name="geometry">
+      <rect>
+       <x>59</x>
+       <y>29</y>
+       <width>661</width>
+       <height>481</height>
+      </rect>
+     </property>
+     <layout class="QGridLayout" name="gridLayout" rowstretch="3,2,1,1,2" columnstretch="1,3">
+      <property name="leftMargin">
+       <number>10</number>
+      </property>
+      <property name="rightMargin">
+       <number>10</number>
+      </property>
+      <item row="1" column="0">
+       <spacer name="verticalSpacer">
+        <property name="orientation">
+         <enum>Qt::Vertical</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>20</width>
+          <height>40</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Nickname:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="0" colspan="2">
+       <widget class="QLabel" name="label">
+        <property name="font">
+         <font>
+          <pointsize>16</pointsize>
+         </font>
+        </property>
+        <property name="text">
+         <string>SETTINGS</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QLineEdit" name="nicknameInput">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="label_3">
+        <property name="text">
+         <string>Server address:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="1">
+       <widget class="QLineEdit" name="serverAddressInput">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="0" colspan="2">
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <property name="leftMargin">
+         <number>200</number>
+        </property>
+        <property name="topMargin">
+         <number>20</number>
+        </property>
+        <property name="rightMargin">
+         <number>200</number>
+        </property>
+        <property name="bottomMargin">
+         <number>20</number>
+        </property>
+        <item>
+         <widget class="QPushButton" name="updateSettingsButton">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Minimum" vsizetype="Ignored">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Update settings</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item row="1" column="1">
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <item>
+         <spacer name="horizontalSpacer">
+          <property name="orientation">
+           <enum>Qt::Horizontal</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>40</width>
+            <height>20</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+        <item>
+         <widget class="QPushButton" name="reloginButton">
+          <property name="text">
+           <string>Change user</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
    </widget>
   </widget>
   <widget class="QMenuBar" name="menubar">
diff --git a/client/views/startview.cpp b/client/views/startview.cpp
index a8b74ef9..5d16b37a 100644
--- a/client/views/startview.cpp
+++ b/client/views/startview.cpp
@@ -5,6 +5,7 @@
 StartView::StartView(QWidget *parent)
     : QMainWindow(parent), ui(new Ui::StartView) {
     ui->setupUi(this);
+    ui->cavokeTestWindowButton->hide();
 }
 
 StartView::~StartView() {
@@ -31,6 +32,14 @@ void StartView::on_cavokeTestWindowButton_clicked() {
     emit shownTestWindowView();
 }
 
+void StartView::on_statisticsButton_clicked() {
+    if (!AuthDialog::verifyAuth(this)) {
+        return;
+    }
+    this->close();
+    emit shownStatisticsView();
+}
+
 void StartView::on_settingsButton_clicked() {
     this->close();
     emit shownSettingsView();
diff --git a/client/views/startview.h b/client/views/startview.h
index a9e791d0..de02fe73 100644
--- a/client/views/startview.h
+++ b/client/views/startview.h
@@ -20,6 +20,7 @@ class StartView : public QMainWindow {
     void shownCreateGameView();
     void shownSettingsView();
     void shownGamesListView();
+    void shownStatisticsView();
     void clickedExitButton();
 
 private slots:
@@ -27,6 +28,7 @@ private slots:
     void on_createGameButton_clicked();
     void on_gamesListButton_clicked();
     void on_cavokeTestWindowButton_clicked();
+    void on_statisticsButton_clicked();
     void on_settingsButton_clicked();
     void on_exitButton_clicked();
 
diff --git a/client/views/startview.ui b/client/views/startview.ui
index 20d74c69..1f84cbde 100644
--- a/client/views/startview.ui
+++ b/client/views/startview.ui
@@ -10,8 +10,20 @@
     <height>600</height>
    </rect>
   </property>
+  <property name="minimumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
   <property name="windowTitle">
-   <string>MainWindow</string>
+   <string>Cavoke</string>
   </property>
   <widget class="QWidget" name="centralwidget">
    <layout class="QVBoxLayout" name="verticalLayout">
@@ -29,21 +41,34 @@
          <x>230</x>
          <y>160</y>
          <width>321</width>
-         <height>194</height>
+         <height>238</height>
         </rect>
        </property>
        <layout class="QVBoxLayout" name="verticalLayout_2">
+        <item>
+         <spacer name="verticalSpacer">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>20</width>
+            <height>40</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
         <item>
          <widget class="QPushButton" name="joinGameButton">
           <property name="text">
-           <string>Join game</string>
+           <string>Join room</string>
           </property>
          </widget>
         </item>
         <item>
          <widget class="QPushButton" name="createGameButton">
           <property name="text">
-           <string>Create game</string>
+           <string>Create room</string>
           </property>
          </widget>
         </item>
@@ -57,27 +82,47 @@
         <item>
          <widget class="QPushButton" name="cavokeTestWindowButton">
           <property name="text">
-           <string>Cavoke test screen</string>
+           <string>Developer mode</string>
           </property>
          </widget>
         </item>
         <item>
-         <spacer name="verticalSpacer">
-          <property name="orientation">
-           <enum>Qt::Vertical</enum>
-          </property>
-          <property name="sizeHint" stdset="0">
-           <size>
-            <width>20</width>
-            <height>40</height>
-           </size>
+         <widget class="QPushButton" name="statisticsButton">
+          <property name="text">
+           <string>Statistics</string>
           </property>
-         </spacer>
+         </widget>
         </item>
         <item>
-         <layout class="QHBoxLayout" name="horizontalLayout">
+         <layout class="QHBoxLayout" name="horizontalLayout" stretch="1,5,6">
+          <property name="spacing">
+           <number>6</number>
+          </property>
+          <item>
+           <widget class="QPushButton" name="pushButton">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Ignored" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>1</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="text">
+             <string/>
+            </property>
+            <property name="icon">
+             <iconset>
+              <normaloff>:/info</normaloff>:/info</iconset>
+            </property>
+           </widget>
+          </item>
           <item>
            <widget class="QPushButton" name="settingsButton">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>3</verstretch>
+             </sizepolicy>
+            </property>
             <property name="text">
              <string>Settings</string>
             </property>
@@ -85,6 +130,12 @@
           </item>
           <item>
            <widget class="QPushButton" name="exitButton">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>3</verstretch>
+             </sizepolicy>
+            </property>
             <property name="text">
              <string>Exit</string>
             </property>
@@ -92,6 +143,68 @@
           </item>
          </layout>
         </item>
+        <item>
+         <spacer name="verticalSpacer_2">
+          <property name="orientation">
+           <enum>Qt::Vertical</enum>
+          </property>
+          <property name="sizeHint" stdset="0">
+           <size>
+            <width>20</width>
+            <height>40</height>
+           </size>
+          </property>
+         </spacer>
+        </item>
+       </layout>
+      </widget>
+      <widget class="QWidget" name="horizontalLayoutWidget">
+       <property name="geometry">
+        <rect>
+         <x>230</x>
+         <y>30</y>
+         <width>321</width>
+         <height>91</height>
+        </rect>
+       </property>
+       <layout class="QHBoxLayout" name="horizontalLayout_2" stretch="1,4">
+        <item>
+         <widget class="QLabel" name="label_2">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Preferred">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string/>
+          </property>
+          <property name="pixmap">
+           <pixmap>:/cavoke</pixmap>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLabel" name="label">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Minimum" vsizetype="Preferred">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="font">
+           <font>
+            <pointsize>16</pointsize>
+           </font>
+          </property>
+          <property name="text">
+           <string>CAVOKE         </string>
+          </property>
+          <property name="alignment">
+           <set>Qt::AlignCenter</set>
+          </property>
+         </widget>
+        </item>
        </layout>
       </widget>
      </widget>
@@ -110,6 +223,8 @@
   </widget>
   <widget class="QStatusBar" name="statusbar"/>
  </widget>
- <resources/>
+ <resources>
+  <include location="resources/resources.qrc"/>
+ </resources>
  <connections/>
 </ui>
diff --git a/client/views/statisticsview.cpp b/client/views/statisticsview.cpp
new file mode 100644
index 00000000..8c1b704a
--- /dev/null
+++ b/client/views/statisticsview.cpp
@@ -0,0 +1,69 @@
+#include "statisticsview.h"
+#include <QFileDialog>
+#include "authdialog.h"
+#include "ui_statisticsview.h"
+
+StatisticsView::StatisticsView(QWidget *parent)
+    : QMainWindow(parent), ui(new Ui::StatisticsView) {
+    ui->setupUi(this);
+    connect(ui->games_combobox, SIGNAL(currentIndexChanged(int)), this,
+            SLOT(repeaterCurrentIndexChanged(int)));
+}
+
+void StatisticsView::repeaterCurrentIndexChanged(int index) {
+    if (index == -1) {
+        displayEmpty();
+        return;
+    }
+    emit statisticsGameChanged(ui->games_combobox->itemData(index).toString());
+}
+
+void StatisticsView::displayEmpty() {
+    ui->time_played_label->setText("0");
+    ui->games_played_label->setText("0");
+    ui->win_rate_label->setText("0");
+}
+
+void StatisticsView::gotUserGameStatisticsUpdate(
+    const UserGameStatistics &userGameStatistics) {
+    ui->time_played_label->setText(
+        QString::number(userGameStatistics.time_played_sec));
+    ui->games_played_label->setText(
+        QString::number(userGameStatistics.games_played));
+    ui->win_rate_label->setText(QString::number(userGameStatistics.win_rate));
+}
+
+StatisticsView::~StatisticsView() {
+    delete ui;
+}
+
+void StatisticsView::on_backButton_clicked() {
+    this->close();
+    emit shownStartView();
+}
+
+void StatisticsView::gotGamesListUpdate(
+    const std::vector<GameInfo> &newGamesList) {
+    ui->games_combobox->clear();
+    for (const auto &gameInfo : newGamesList) {
+        ui->games_combobox->addItem(gameInfo.display_name, gameInfo.id);
+    }
+}
+void StatisticsView::gotUserStatisticsUpdate(
+    const UserStatistics &userStatistics) {
+    ui->total_time_played_label->setText(
+        QString::number(userStatistics.total_time_played_sec));
+    ui->total_games_played_label->setText(
+        QString::number(userStatistics.total_games_played));
+}
+
+void StatisticsView::requestUpdates() {
+    emit requestedRefresh();
+    emit statisticsGameChanged(
+        ui->games_combobox->itemData(ui->games_combobox->currentIndex())
+            .toString());
+}
+
+void StatisticsView::on_refreshButton_clicked() {
+    requestUpdates();
+}
diff --git a/client/views/statisticsview.h b/client/views/statisticsview.h
new file mode 100644
index 00000000..c840d84d
--- /dev/null
+++ b/client/views/statisticsview.h
@@ -0,0 +1,41 @@
+#ifndef CAVOKE_CLIENT_STATISTICSVIEW_H
+#define CAVOKE_CLIENT_STATISTICSVIEW_H
+
+#include <QMainWindow>
+#include "entities/gameinfo.h"
+#include "entities/usergamestatistics.h"
+#include "entities/userstatistics.h"
+
+namespace Ui {
+class StatisticsView;
+}
+
+class StatisticsView : public QMainWindow {
+    Q_OBJECT
+public:
+    explicit StatisticsView(QWidget *parent = nullptr);
+    ~StatisticsView();
+
+public slots:
+    void gotGamesListUpdate(const std::vector<GameInfo> &newGamesList);
+    void gotUserStatisticsUpdate(const UserStatistics &userStatistics);
+    void gotUserGameStatisticsUpdate(
+        const UserGameStatistics &userGameStatistics);
+    void requestUpdates();
+
+signals:
+    void shownStartView();
+    void requestedRefresh();
+    void statisticsGameChanged(const QString &gameId);
+
+private slots:
+    void on_backButton_clicked();
+    void on_refreshButton_clicked();
+    void displayEmpty();
+    void repeaterCurrentIndexChanged(int index);
+
+private:
+    Ui::StatisticsView *ui;
+};
+
+#endif  // CAVOKE_CLIENT_STATISTICSVIEW_H
diff --git a/client/views/statisticsview.ui b/client/views/statisticsview.ui
new file mode 100644
index 00000000..9eb62350
--- /dev/null
+++ b/client/views/statisticsview.ui
@@ -0,0 +1,222 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>StatisticsView</class>
+ <widget class="QMainWindow" name="StatisticsView">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>800</width>
+    <height>600</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Cavoke</string>
+  </property>
+  <widget class="QWidget" name="centralwidget">
+   <widget class="QGroupBox" name="groupBox">
+    <property name="geometry">
+     <rect>
+      <x>9</x>
+      <y>9</y>
+      <width>782</width>
+      <height>541</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string/>
+    </property>
+    <widget class="QPushButton" name="backButton">
+     <property name="geometry">
+      <rect>
+       <x>1</x>
+       <y>4</y>
+       <width>61</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Back</string>
+     </property>
+    </widget>
+    <widget class="QWidget" name="gridLayoutWidget">
+     <property name="geometry">
+      <rect>
+       <x>59</x>
+       <y>29</y>
+       <width>661</width>
+       <height>481</height>
+      </rect>
+     </property>
+     <layout class="QGridLayout" name="gridLayout" rowstretch="4,1,1,1,1,1,1,3,0" columnstretch="2,3">
+      <property name="leftMargin">
+       <number>10</number>
+      </property>
+      <property name="rightMargin">
+       <number>10</number>
+      </property>
+      <item row="6" column="1">
+       <widget class="QLabel" name="win_rate_label">
+        <property name="text">
+         <string>0</string>
+        </property>
+       </widget>
+      </item>
+      <item row="5" column="0">
+       <widget class="QLabel" name="label_8">
+        <property name="text">
+         <string>Games played:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="0">
+       <widget class="QLabel" name="label_6">
+        <property name="text">
+         <string>Statistics for game:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="0">
+       <widget class="QLabel" name="label_7">
+        <property name="text">
+         <string>Time played, seconds:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="0">
+       <widget class="QLabel" name="label_2">
+        <property name="text">
+         <string>Total games played:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="5" column="1">
+       <widget class="QLabel" name="games_played_label">
+        <property name="text">
+         <string>0</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="1">
+       <widget class="QLabel" name="total_time_played_label">
+        <property name="text">
+         <string>0</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="1">
+       <widget class="QComboBox" name="games_combobox">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+          <horstretch>0</horstretch>
+          <verstretch>0</verstretch>
+         </sizepolicy>
+        </property>
+       </widget>
+      </item>
+      <item row="0" column="0" colspan="2">
+       <widget class="QLabel" name="label">
+        <property name="font">
+         <font>
+          <pointsize>16</pointsize>
+         </font>
+        </property>
+        <property name="layoutDirection">
+         <enum>Qt::LeftToRight</enum>
+        </property>
+        <property name="text">
+         <string>STATISTICS</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignCenter</set>
+        </property>
+       </widget>
+      </item>
+      <item row="2" column="1">
+       <widget class="QLabel" name="total_games_played_label">
+        <property name="text">
+         <string>0</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="1">
+       <widget class="QLabel" name="time_played_label">
+        <property name="text">
+         <string>0</string>
+        </property>
+       </widget>
+      </item>
+      <item row="1" column="0">
+       <widget class="QLabel" name="label_3">
+        <property name="text">
+         <string>Total tme played, seconds:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="6" column="0">
+       <widget class="QLabel" name="label_9">
+        <property name="text">
+         <string>Win rate:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="7" column="0" colspan="2">
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <property name="leftMargin">
+         <number>200</number>
+        </property>
+        <property name="topMargin">
+         <number>20</number>
+        </property>
+        <property name="rightMargin">
+         <number>200</number>
+        </property>
+        <property name="bottomMargin">
+         <number>20</number>
+        </property>
+        <item>
+         <widget class="QPushButton" name="refreshButton">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Ignored">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Refresh</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </widget>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>800</width>
+     <height>28</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/client/views/testwindowview.ui b/client/views/testwindowview.ui
index 5c675ded..4dba215c 100644
--- a/client/views/testwindowview.ui
+++ b/client/views/testwindowview.ui
@@ -10,8 +10,20 @@
     <height>600</height>
    </rect>
   </property>
+  <property name="minimumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>800</width>
+    <height>600</height>
+   </size>
+  </property>
   <property name="windowTitle">
-   <string>MainWindow</string>
+   <string>Cavoke</string>
   </property>
   <widget class="QWidget" name="centralwidget">
    <widget class="QLineEdit" name="appPathInput">
diff --git a/db.Dockerfile b/db.Dockerfile
new file mode 100644
index 00000000..7aee07ae
--- /dev/null
+++ b/db.Dockerfile
@@ -0,0 +1,3 @@
+FROM postgres
+ENV POSTGRES_DB cavoke
+COPY ./server/db/schema.sql /docker-entrypoint-initdb.d/
\ No newline at end of file
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 00000000..88f453ef
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,22 @@
+version: "3.9"
+
+services:
+  db:
+    build:
+      context: .
+      dockerfile: db.Dockerfile
+    environment:
+      - POSTGRES_DB=cavoke
+      - POSTGRES_USER=postgres_user
+      - POSTGRES_PASSWORD=postgres_password
+  cavoke_server:
+    build:
+      context: .
+      dockerfile: server.Dockerfile
+    command: -p 8080 -c /mnt/data/drogon_config.json
+    depends_on:
+      - db
+    volumes:
+      - ./example/server_data:/mnt/data
+    ports:
+      - "8080:8080"
diff --git a/example/server_data/drogon_config.json b/example/server_data/drogon_config.json
new file mode 100644
index 00000000..64c40cea
--- /dev/null
+++ b/example/server_data/drogon_config.json
@@ -0,0 +1,137 @@
+/* This is a JSON format configuration file
+ */
+{
+  //custom_config: custom configuration for users. This object can be acquired by the app().getCustomConfig() method.
+  "custom_config": {
+    "storage": {
+      "games_directory": "/mnt/data/games",
+      "logic_name": "logic",
+      "zip_name": "client.zip",
+      "config_name": "config.json"
+    }
+  },
+  "db_clients": [
+    {
+      //name: Name of the client,'default' by default
+      "name": "default",
+      //rdbms: Server type, postgresql,mysql or sqlite3, "postgresql" by default
+      "rdbms": "postgresql",
+      //filename: Sqlite3 db file name
+      //"filename":"",
+      //host: Server address,localhost by default
+      "host": "db",
+      //port: Server port, 5432 by default
+      "port": 5432,
+      //dbname: Database name
+      "dbname": "cavoke",
+      //user: 'postgres' by default
+      "user": "postgres_user",
+      //passwd: '' by default
+      "passwd": "postgres_password",
+      //is_fast: false by default, if it is true, the client is faster but user can't call
+      //any synchronous interface of it.
+      "is_fast": false,
+      //client_encoding: The character set used by the client. it is empty string by default which
+      //means use the default character set.
+      //"client_encoding": "",
+      //number_of_connections: 1 by default, if the 'is_fast' is true, the number is the number of
+      //connections per IO thread, otherwise it is the total number of all connections.
+      "number_of_connections": 20,
+      //timeout: -1.0 by default, in seconds, the timeout for executing a SQL query.
+      //zero or negative value means no timeout.
+      "timeout": -1.0
+    }
+  ],
+  "app": {
+    //number_of_threads: The number of IO threads, 1 by default, if the value is set to 0, the number of threads
+    //is the number of CPU cores
+    "number_of_threads": 1,
+    //enable_session: False by default
+    "enable_session": false,
+    "session_timeout": 0,
+    //max_connections: maximum number of connections, 100000 by default
+    "max_connections": 100000,
+    //max_connections_per_ip: maximum number of connections per client, 0 by default which means no limit
+    "max_connections_per_ip": 0,
+    //Load_dynamic_views: False by default, when set to true, drogon
+    //compiles and loads dynamically "CSP View Files" in directories defined
+    //by "dynamic_views_path"
+    "load_dynamic_views": false,
+    //dynamic_views_path: If the path isn't prefixed with /, ./ or ../,
+    //it is relative path of document_root path
+    "dynamic_views_path": [
+      "./views"
+    ],
+    //dynamic_views_output_path: Default by an empty string which means the output path of source
+    //files is the path where the csp files locate. If the path isn't prefixed with /, it is relative
+    //path of the current working directory.
+    "dynamic_views_output_path": "",
+    //enable_unicode_escaping_in_json: true by default, enable unicode escaping in json.
+    "enable_unicode_escaping_in_json": true,
+    //float_precision_in_json: set precision of float number in json.
+    "float_precision_in_json": {
+      //precision: 0 by default, 0 means use the default precision of the jsoncpp lib.
+      "precision": 0,
+      //precision_type: must be "significant" or "decimal", defaults to "significant" that means
+      //setting max number of significant digits in string, "decimal" means setting max number of
+      //digits after "." in string
+      "precision_type": "significant"
+    },
+    //run_as_daemon: False by default
+    "run_as_daemon": false,
+    //handle_sig_term: True by default
+    "handle_sig_term": true,
+    //relaunch_on_error: False by default, if true, the program will be restarted by the parent after exiting;
+    "relaunch_on_error": false,
+    //use_sendfile: True by default, if true, the program
+    //uses sendfile() system-call to send static files to clients;
+    "use_sendfile": true,
+    //use_gzip: True by default, use gzip to compress the response body's content;
+    "use_gzip": true,
+    //use_brotli: False by default, use brotli to compress the response body's content;
+    "use_brotli": false,
+    //static_files_cache_time: 5 (seconds) by default, the time in which the static file response is cached,
+    //0 means cache forever, the negative value means no cache
+    "static_files_cache_time": 5,
+    //idle_connection_timeout: Defaults to 60 seconds, the lifetime
+    //of the connection without read or write
+    "idle_connection_timeout": 60,
+    //server_header_field: Set the 'Server' header field in each response sent by drogon,
+    //empty string by default with which the 'Server' header field is set to "Server: drogon/version string\r\n"
+    "server_header_field": "",
+    //enable_server_header: Set true to force drogon to add a 'Server' header to each HTTP response. The default
+    //value is true.
+    "enable_server_header": true,
+    //enable_date_header: Set true to force drogon to add a 'Date' header to each HTTP response. The default
+    //value is true.
+    "enable_date_header": true,
+    //keepalive_requests: Set the maximum number of requests that can be served through one keep-alive connection.
+    //After the maximum number of requests are made, the connection is closed.
+    //The default value of 0 means no limit.
+    "keepalive_requests": 0,
+    //pipelining_requests: Set the maximum number of unhandled requests that can be cached in pipelining buffer.
+    //After the maximum number of requests are made, the connection is closed.
+    //The default value of 0 means no limit.
+    "pipelining_requests": 0,
+    //gzip_static: If it is set to true, when the client requests a static file, drogon first finds the compressed
+    //file with the extension ".gz" in the same path and send the compressed file to the client.
+    //The default value of gzip_static is true.
+    "gzip_static": true,
+    //br_static: If it is set to true, when the client requests a static file, drogon first finds the compressed
+    //file with the extension ".br" in the same path and send the compressed file to the client.
+    //The default value of br_static is true.
+    "br_static": true,
+    //client_max_body_size: Set the maximum body size of HTTP requests received by drogon. The default value is "1M".
+    //One can set it to "1024", "1k", "10M", "1G", etc. Setting it to "" means no limit.
+    "client_max_body_size": "1M",
+    //max_memory_body_size: Set the maximum body size in memory of HTTP requests received by drogon. The default value is "64K" bytes.
+    //If the body size of an HTTP request exceeds this limit, the body is stored to a temporary file for processing.
+    //Setting it to "" means no limit.
+    "client_max_memory_body_size": "64K",
+    //client_max_websocket_message_size: Set the maximum size of messages sent by WebSocket client. The default value is "128K".
+    //One can set it to "1024", "1k", "10M", "1G", etc. Setting it to "" means no limit.
+    "client_max_websocket_message_size": "128K",
+    //reuse_port: Defaults to false, users can run multiple processes listening on the same port at the same time.
+    "reuse_port": false
+  }
+}
diff --git a/example/server_data/games/tictactoe/client.zip b/example/server_data/games/tictactoe/client.zip
new file mode 100644
index 00000000..d8d27e31
Binary files /dev/null and b/example/server_data/games/tictactoe/client.zip differ
diff --git a/example/server_data/games/tictactoe/config.json b/example/server_data/games/tictactoe/config.json
new file mode 100644
index 00000000..cdea6e6d
--- /dev/null
+++ b/example/server_data/games/tictactoe/config.json
@@ -0,0 +1,15 @@
+{
+  "default_settings": {
+    "board_size": 3
+  },
+  "description": "Paper-and-pencil game for two players who take turns marking the spaces in a three-by-three grid with X or O",
+  "display_name": "Tic-tac-toe",
+  "id": "tictactoe",
+  "players_num": 2,
+  "role_names": [
+    "Crosses",
+    "Noughts"
+  ],
+  "app_type": "LOCAL",
+  "url": ""
+}
diff --git a/example/server_data/games/tictactoe/logic b/example/server_data/games/tictactoe/logic
new file mode 100644
index 00000000..eaf7d18c
Binary files /dev/null and b/example/server_data/games/tictactoe/logic differ
diff --git a/games/CMakeLists.txt b/games/CMakeLists.txt
index 04d1c6e0..f25d07dc 100644
--- a/games/CMakeLists.txt
+++ b/games/CMakeLists.txt
@@ -1,10 +1,59 @@
 cmake_minimum_required(VERSION 3.10)
-project(tictactoe)
+project(games)
 
-find_package(nlohmann_json 3.9.0 REQUIRED)
+set(CMAKE_CXX_STANDARD 17)
+
+set(CAVOKE_H_DIR ../cavoke-dev-lib CACHE PATH "Directory with cavoke.h library" FORCE)
+set(CAVOKE_DEV_SERVER_H_DIR ../cavoke-dev-server-lib CACHE PATH "Directory with game dev server library" FORCE)
+include_directories(${CAVOKE_H_DIR})
+include_directories(${CAVOKE_DEV_SERVER_H_DIR})
 
 add_executable(tictactoe
         tictactoe/tictactoe.cpp
-        cavoke.cpp)
+        ${CAVOKE_H_DIR}/cavoke.cpp)
+
+add_executable(codenames
+        codenames/server/src/codenames.cpp
+        codenames/server/src/wordlists.cpp
+        ${CAVOKE_H_DIR}/cavoke.cpp codenames/server/src/model.cpp)
+
+add_executable(tictactoe_server
+        tictactoe/tictactoe.cpp
+        ${CAVOKE_DEV_SERVER_H_DIR}/cavoke.cpp
+        ${CAVOKE_DEV_SERVER_H_DIR}/controllers/logic_controller.cpp)
+
+add_executable(codenames_server
+        codenames/server/src/codenames.cpp
+        codenames/server/src/wordlists.cpp
+        codenames/server/src/model.cpp
+        ${CAVOKE_DEV_SERVER_H_DIR}/cavoke.cpp
+        ${CAVOKE_DEV_SERVER_H_DIR}/controllers/logic_controller.cpp)
+
+if (USE_EXTERNAL_NLOHMANN)
+    target_link_libraries(tictactoe PRIVATE nlohmann_json::nlohmann_json)
+    target_link_libraries(tictactoe_server PRIVATE nlohmann_json::nlohmann_json)
+    target_link_libraries(codenames PRIVATE nlohmann_json::nlohmann_json)
+    target_link_libraries(codenames_server PRIVATE nlohmann_json::nlohmann_json)
+else ()
+    target_link_libraries(tictactoe PRIVATE nlohmann_json)
+    target_link_libraries(tictactoe_server PRIVATE nlohmann_json)
+    target_link_libraries(codenames PRIVATE nlohmann_json)
+    target_link_libraries(codenames_server PRIVATE nlohmann_json)
+endif ()
+
+# Link Drogon
+if (USE_EXTERNAL_DROGON)
+    target_link_libraries(tictactoe_server PRIVATE Drogon::Drogon)
+    target_link_libraries(codenames_server PRIVATE Drogon::Drogon)
+else ()
+    target_link_libraries(tictactoe_server PRIVATE drogon)
+    target_link_libraries(codenames_server PRIVATE drogon)
+endif ()
+
+# Link Boost
+find_package(Boost 1.71 REQUIRED filesystem program_options)
+include_directories(${Boost_INCLUDE_DIRS})
+link_directories(${Boost_LIBRARY_DIRS})
 
-target_link_libraries(tictactoe nlohmann_json::nlohmann_json)
+target_link_libraries(tictactoe_server PRIVATE ${Boost_LIBRARIES} ${CMAKE_DL_LIBS})
+target_link_libraries(codenames_server PRIVATE ${Boost_LIBRARIES} ${CMAKE_DL_LIBS})
diff --git a/games/codenames/client/build.sh b/games/codenames/client/build.sh
new file mode 100644
index 00000000..172313f0
--- /dev/null
+++ b/games/codenames/client/build.sh
@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+mkdir -p .build/client
+cp -r codenames-client/app.qml .build/client/app.qml
+cp -r codenames-client/src .build/client/src
+cd .build
+zip -r ../client.zip client
+cd ..
+rm -r .build
diff --git a/games/codenames/client/codenames-client/app.qml b/games/codenames/client/codenames-client/app.qml
new file mode 100644
index 00000000..65d0d45a
--- /dev/null
+++ b/games/codenames/client/codenames-client/app.qml
@@ -0,0 +1,15 @@
+import QtQuick 2.15
+import QtQuick.Window 2.15
+import "src/components"
+import "src/screens"
+
+Rectangle {
+    width: 1280
+    height: 768
+    //anchors.fill: parent
+    visible: true
+
+    Game {
+        anchors.fill: parent
+    }
+}
diff --git a/games/codenames/client/codenames-client/src/components/Card.qml b/games/codenames/client/codenames-client/src/components/Card.qml
new file mode 100644
index 00000000..1dba1b56
--- /dev/null
+++ b/games/codenames/client/codenames-client/src/components/Card.qml
@@ -0,0 +1,72 @@
+import QtQuick 2.0
+
+import "../interactions/interactions.js" as Interact
+import "../style/colors.js" as Colors
+
+Item {
+    id: card;
+
+    property string word: ""
+    property int state: 0
+    property bool opened: false
+    property int player: 0
+    property int card_index: 0
+    width: 180
+    height: 100
+
+    function getColor(state, opened, player) {
+        if (state === 0) {
+            if (player >= 2 || !opened) {
+                return Colors.BLUE_AGENT;
+            }
+            return Colors.BLUE_AGENT_OPENED;
+        } else if (state === 1) {
+            if (player >= 2 || !opened) {
+                return Colors.RED_AGENT;
+            }
+            return Colors.RED_AGENT_OPENED;
+        } else if (state === 2) {
+            return Colors.BLACK_CARD;
+        } else if (state === 3) {
+            if (player >= 2 || !opened) {
+                return Colors.NEUTRAL;
+            }
+            return Colors.NEUTRAL_OPENED;
+        } else {
+            return Colors.CLOSED;
+        }
+    }
+
+    function getTextColor(state) {
+        return "white";
+    }
+
+    function getText(state, player, word) {
+        if (state === 4 || player === 0 || player === 1) {
+            return word;
+        } else {
+            return "";
+        }
+    }
+
+    Rectangle {
+        id: card_content
+        anchors.fill: parent
+//        radius: 10
+
+        color: getColor(card.state, card.opened, card.player);
+
+        Text {
+            id: card_hint;
+
+            anchors.centerIn: parent;
+            text: getText(card.state, card.player, card.word);
+            color: getTextColor(card.state);
+        }
+
+        MouseArea {
+            anchors.fill: parent
+            onClicked: Interact.openCard(parent.parent.card_index);
+        }
+    }
+}
diff --git a/games/codenames/client/codenames-client/src/interactions/interactions.js b/games/codenames/client/codenames-client/src/interactions/interactions.js
new file mode 100644
index 00000000..45b0d55c
--- /dev/null
+++ b/games/codenames/client/codenames-client/src/interactions/interactions.js
@@ -0,0 +1,118 @@
+let previousState = "";
+
+function sendMove(move) {
+    let moveObj = {}
+    moveObj.move = JSON.stringify(move);
+    cavoke.getMoveFromQml(JSON.stringify(moveObj));
+}
+
+function makeHint(hint, attempts = 1) {
+    if (!hint || !attempts || attempts <= 0) {
+        return;
+    }
+    console.log("Make hint", hint);
+    sendMove({type: "hint", hint: hint, attempts: attempts});
+}
+
+function openCard(index) {
+    console.log("Open card", index);
+    sendMove({type: "open", position: index});
+}
+
+function skip() {
+    console.log("Skip move");
+    sendMove({type: "skip"});
+}
+
+function getRoleName(role) {
+    if (role === 0) {
+        return "blue captain";
+    } else if (role === 1) {
+        return "red captain";
+    } else if (role % 2 === 0) {
+        return "blue player";
+    } else {
+        return "red player";
+    }
+}
+
+function isYourTurn(role, stage) {
+    if (stage === 0) {
+        return role === 0;
+    } else if (stage === 2) {
+        return role === 1;
+    } else if (stage === 1) {
+        return role === 2 || role === 4;
+    } else if (stage === 3) {
+        return role === 3 || role === 5;
+    }
+
+    return false;
+}
+
+
+function updateInterface(model) {
+    let result = model.m_result;
+
+    if (result === 1) {
+        resultsScreen.visible = true;
+        gameBoard.opacity = 0.33;
+
+        blueWins.visible = true;
+        redWins.visible = false;
+    } else if (result === 2) {
+        resultsScreen.visible = true;
+        gameBoard.opacity = 0.33;
+
+        blueWins.visible = false;
+        redWins.visible = true;
+    } else {
+        resultsScreen.visible = false;
+        gameBoard.opacity = 1;
+    }
+
+    board.rows = model.m_height;
+    board.columns = model.m_width;
+    let stage = model.m_stage;
+    let player = model.role;
+    hintControls.visible = ((stage === 0 && player === 0) || (stage === 2 && player === 1));
+    if (model.m_last_hint) {
+        currentHint.text = "\"" + model.m_last_hint + "\"";
+    } else {
+        currentHint.text = "none";
+    }
+    currentAttempts.text = model.m_attempts_left.toString();
+    yourRole.text = getRoleName(player);
+
+    yourTurnLabel.visible = isYourTurn(player, model.m_stage);
+    skipControls.visible = yourTurnLabel.visible && (player >= 2);
+
+    blueCardsLeft.text = model.m_blue_closed.toString();
+    redCardsLeft.text = model.m_red_closed.toString();
+
+    for (let i = 0; i < model.m_height; ++i) {
+        for (let j = 0; j < model.m_width; ++j) {
+            if (board.children.length < (i * model.m_width + j) + 1) {
+                let component = Qt.createComponent("../components/Card.qml");
+                component.createObject(board);
+            }
+            let card = board.children[(i * model.m_width + j)];
+            card.word = model.m_words[(i * model.m_width + j)];
+            card.state = model.m_card_states[(i * model.m_width + j)];
+            card.player = player;
+            if (player <= 1) {
+                card.opened = model.m_opened[(i * model.m_width + j)];
+            }
+            card.card_index = (i * model.m_width + j);
+        }
+    }
+}
+
+function processUpdate(update_str) {
+    let update = JSON.parse(update_str);
+    let model = JSON.parse(update.state);
+    if (model !== previousState) {
+        previousState = model;
+        updateInterface(model);
+    }
+}
diff --git a/games/codenames/client/codenames-client/src/screens/Game.qml b/games/codenames/client/codenames-client/src/screens/Game.qml
new file mode 100644
index 00000000..55b74238
--- /dev/null
+++ b/games/codenames/client/codenames-client/src/screens/Game.qml
@@ -0,0 +1,248 @@
+import QtQuick 2.0
+import QtQuick.Controls 2.15
+import QtQuick.Layouts 1.15
+
+
+import "../components"
+import "../interactions/interactions.js" as Interact
+import "../style/colors.js" as Colors
+
+Rectangle {
+    // BEGIN cavoke section
+    Connections {
+        target: cavoke
+
+        function onReceiveUpdate(jsonUpdate) {
+            console.log("Received: " + jsonUpdate);
+            Interact.processUpdate(jsonUpdate);
+        }
+    }
+    // END cavoke section
+    Item {
+        id: gameBoard;
+        visible: true;
+        anchors.fill: parent;
+
+        Rectangle {
+            color: "#f0ffff";
+            anchors.fill: parent;
+            Grid {
+               id: board
+               anchors.centerIn: parent
+               spacing: 5;
+            }
+        }
+
+        ColumnLayout {
+                id: cardsLeftBlock;
+
+                anchors.top: parent.top;
+                anchors.left: parent.left;
+                anchors.topMargin: 25;
+                anchors.leftMargin: 25;
+
+                RowLayout {
+                    anchors.left: parent.left;
+                    Text {
+                        id: blueCardsLeftLabel;
+                        color: Colors.BLUE_AGENT;
+                        text: "Blue cards left: "
+                        anchors.left: parent.left;
+                    }
+                    Text {
+                        id: blueCardsLeft;
+                        color: Colors.BLUE_AGENT;
+                        anchors.left: blueCardsLeftLabel.right;
+                    }
+                }
+
+                RowLayout {
+                    anchors.topMargin: 5;
+                    anchors.left: parent.left;
+
+                    Text {
+                        id: redCardsLeftLabel;
+                        color: Colors.RED_AGENT;
+                        text: "Red cards left: "
+                        anchors.left: parent.left;
+                    }
+                    Text {
+                        id: redCardsLeft;
+                        color: Colors.RED_AGENT;
+                        anchors.left: redCardsLeftLabel.right;
+                    }
+                }
+
+            }
+
+        RowLayout {
+            id: currentHintBlock;
+
+            anchors.top: parent.top;
+            anchors.horizontalCenter: parent.horizontalCenter;
+            anchors.topMargin: 25;
+            Text {
+                id: currentHintLabel;
+                color: "black";
+                text: "Current hint: "
+                anchors.left: parent.left;
+            }
+            Text {
+                id: currentHint;
+                color: "black";
+                anchors.left: currentHintLabel.right;
+            }
+            Text {
+                id: currentAttemptsLabel;
+                color: "black";
+                text: "attempts left: "
+                anchors.left: currentHint.right;
+                anchors.leftMargin: 50;
+            }
+            Text {
+                id: currentAttempts;
+                color: "black";
+                anchors.left: currentAttemptsLabel.right;
+            }
+
+        }
+
+        Text {
+            id: yourTurnLabel;
+            color: "black";
+            text: "Your turn!";
+            anchors.right: yourRoleBlock.right;
+            anchors.top: yourRoleBlock.bottom;
+            anchors.topMargin: 5;
+
+            visible: false;
+        }
+
+        RowLayout {
+            id: yourRoleBlock;
+
+            anchors.top: parent.top;
+            anchors.right: parent.right;
+            anchors.topMargin: 25;
+            anchors.rightMargin: 25;
+            Text {
+                id: yourRoleLabel;
+                color: "black";
+                text: "Your role is: "
+                anchors.right: yourRole.left;
+            }
+            Text {
+                id: yourRole;
+                color: "black";
+                anchors.right: parent.right;
+            }
+
+        }
+
+        RowLayout {
+            id: hintControls;
+
+            anchors.bottom: parent.bottom;
+            anchors.horizontalCenter: parent.horizontalCenter;
+            anchors.bottomMargin: 25;
+
+            Rectangle {
+                color: "white";
+                border.width: 1;
+                border.color: "black";
+
+                width: 600;
+                height: 30;
+                TextInput {
+                    anchors.fill: parent;
+                    anchors.leftMargin: 3;
+                    id: hintInput;
+                    visible: true;
+                    verticalAlignment: Qt.AlignVCenter;
+                    font.capitalization: Font.AllLowercase
+                    font.pointSize: 15;
+                    maximumLength: 37;
+                }
+            }
+
+            Rectangle {
+                color: "white";
+                border.width: 1;
+                border.color: "black";
+
+                width: 75;
+                height: 30;
+                anchors.leftMargin: 5
+                TextInput {
+                    anchors.fill: parent;
+                    anchors.leftMargin: 3;
+                    id: attemptsInput;
+                    visible: true;
+                    verticalAlignment: Qt.AlignVCenter;
+                    font.pointSize: 15;
+                    validator: IntValidator {bottom: 1; top: 200}
+                }
+            }
+
+            Button {
+                id: hintSubmit;
+                text: "Submit";
+                onClicked: {
+                    let hint = hintInput.text
+                    let attempts = attemptsInput.text;
+                    hintInput.text = "";
+                    attemptsInput.text = "";
+                    Interact.makeHint(hint, parseInt(attempts));
+                }
+                width: 100;
+                height: 30;
+                anchors.leftMargin: 5
+            }
+        }
+
+        RowLayout {
+            id: skipControls;
+
+            anchors.bottom: parent.bottom;
+            anchors.horizontalCenter: parent.horizontalCenter;
+            anchors.bottomMargin: 25;
+            Button {
+                id: skipButton;
+                text: "Skip";
+                onClicked: {
+                    Interact.skip();
+                }
+                width: 100;
+                height: 30;
+
+            }
+        }
+    }
+    Item {
+        id: resultsScreen;
+        visible: false;
+        anchors.centerIn: parent;
+        anchors.fill: parent;
+        Text {
+            id: blueWins;
+            visible: false;
+            text: "Blue team wins!";
+            color: Colors.BLUE_AGENT;
+            font.pointSize: 64;
+
+            anchors.centerIn: parent;
+        }
+
+        Text {
+            id: redWins;
+            visible: false;
+            text: "Red team wins!";
+            color: Colors.RED_AGENT;
+            font.pointSize: 64;
+
+            anchors.centerIn: parent;
+        }
+    }
+
+//    Component.onCompleted: drawBoard(5, 5, [], [])
+}
diff --git a/games/codenames/client/codenames-client/src/style/colors.js b/games/codenames/client/codenames-client/src/style/colors.js
new file mode 100644
index 00000000..138b3f1e
--- /dev/null
+++ b/games/codenames/client/codenames-client/src/style/colors.js
@@ -0,0 +1,12 @@
+const RED_AGENT = "#FF6B6B";
+const RED_AGENT_OPENED = "#A20000";
+
+const BLUE_AGENT = "#4D96FF";
+const BLUE_AGENT_OPENED = "#003D95";
+
+const NEUTRAL = "#6BCB77";
+const NEUTRAL_OPENED = "#24672C";
+
+const BLACK_CARD = "#272838";
+
+const CLOSED = "#5D536B";
diff --git a/games/codenames/config.json b/games/codenames/config.json
new file mode 100644
index 00000000..5f81e6c7
--- /dev/null
+++ b/games/codenames/config.json
@@ -0,0 +1,19 @@
+{
+  "id": "codenames",
+  "display_name": "Codenames",
+  "description": "Two teams compete by each having a \"spymaster\" give one-word clues that can point to multiple words on the board. The other players on the team attempt to guess their team's words while avoiding the words of the other team.",
+  "players_num": 6,
+  "role_names": [
+    "blue captain",
+    "red captain",
+    "blue player",
+    "red player",
+    "blue player",
+    "red player"
+  ],
+  "default_settings": {
+    "board_h": 5,
+    "board_w": 5,
+    "word_list": "ru"
+  }
+}
diff --git a/games/codenames/server/assets/wordlists/en.txt b/games/codenames/server/assets/wordlists/en.txt
new file mode 100644
index 00000000..76f8e66d
--- /dev/null
+++ b/games/codenames/server/assets/wordlists/en.txt
@@ -0,0 +1,673 @@
+Acne
+Acre
+Addendum
+Advertise
+Aircraft
+Aisle
+Alligator
+Alphabetize
+America
+Ankle
+Apathy
+Applause
+Applesauc
+Application
+Archaeologist
+Aristocrat
+Arm
+Armada
+Asleep
+Astronaut
+Athlete
+Atlantis
+Aunt
+Avocado
+Baby-Sitter
+Backbone
+Bag
+Baguette
+Bald
+Balloon
+Banana
+Banister
+Baseball
+Baseboards
+Basketball
+Bat
+Battery
+Beach
+Beanstalk
+Bedbug
+Beer
+Beethoven
+Belt
+Bib
+Bicycle
+Big
+Bike
+Billboard
+Bird
+Birthday
+Bite
+Blacksmith
+Blanket
+Bleach
+Blimp
+Blossom
+Blueprint
+Blunt
+Blur
+Boa
+Boat
+Bob
+Bobsled
+Body
+Bomb
+Bonnet
+Book
+Booth
+Bowtie
+Box
+Boy
+Brainstorm
+Brand
+Brave
+Bride
+Bridge
+Broccoli
+Broken
+Broom
+Bruise
+Brunette
+Bubble
+Buddy
+Buffalo
+Bulb
+Bunny
+Bus
+Buy
+Cabin
+Cafeteria
+Cake
+Calculator
+Campsite
+Can
+Canada
+Candle
+Candy
+Cape
+Capitalism
+Car
+Cardboard
+Cartography
+Cat
+Cd
+Ceiling
+Cell
+Century
+Chair
+Chalk
+Champion
+Charger
+Cheerleader
+Chef
+Chess
+Chew
+Chicken
+Chime
+China
+Chocolate
+Church
+Circus
+Clay
+Cliff
+Cloak
+Clockwork
+Clown
+Clue
+Coach
+Coal
+Coaster
+Cog
+Cold
+College
+Comfort
+Computer
+Cone
+Constrictor
+Continuum
+Conversation
+Cook
+Coop
+Cord
+Corduroy
+Cot
+Cough
+Cow
+Cowboy
+Crayon
+Cream
+Crisp
+Criticize
+Crow
+Cruise
+Crumb
+Crust
+Cuff
+Curtain
+Cuticle
+Czar
+Dad
+Dart
+Dawn
+Day
+Deep
+Defect
+Dent
+Dentist
+Desk
+Dictionary
+Dimple
+Dirty
+Dismantle
+Ditch
+Diver
+Doctor
+Dog
+Doghouse
+Doll
+Dominoes
+Door
+Dot
+Drain
+Draw
+Dream
+Dress
+Drink
+Drip
+Drums
+Dryer
+Duck
+Dump
+Dunk
+Dust
+Ear
+Eat
+Ebony
+Elbow
+Electricity
+Elephant
+Elevator
+Elf
+Elm
+Engine
+England
+Ergonomic
+Escalator
+Eureka
+Europe
+Evolution
+Extension
+Eyebrow
+Fan
+Fancy
+Fast
+Feast
+Fence
+Feudalism
+Fiddle
+Figment
+Finger
+Fire
+First
+Fishing
+Fix
+Fizz
+Flagpole
+Flannel
+Flashlight
+Flock
+Flotsam
+Flower
+Flu
+Flush
+Flutter
+Fog
+Foil
+Football
+Forehead
+Forever
+Fortnight
+France
+Freckle
+Freight
+Fringe
+Frog
+Frown
+Gallop
+Game
+Garbage
+Garden
+Gasoline
+Gem
+Ginger
+Gingerbread
+Girl
+Glasses
+Goblin
+Gold
+Goodbye
+Grandpa
+Grape
+Grass
+Gratitude
+Gray
+Green
+Guitar
+Gum
+Gumball
+Hair
+Half
+Handle
+Handwriting
+Hang
+Happy
+Hat
+Hatch
+Headache
+Heart
+Hedge
+Helicopter
+Hem
+Hide
+Hill
+Hockey
+Homework
+Honk
+Hopscotch
+Horse
+Hose
+Hot
+House
+Houseboat
+Hug
+Humidifier
+Hungry
+Hurdle
+Hurt
+Hut
+Ice
+Implode
+Inn
+Inquisition
+Intern
+Internet
+Invitation
+Ironic
+Ivory
+Ivy
+Jade
+Japan
+Jeans
+Jelly
+Jet
+Jig
+Jog
+Journal
+Jump
+Key
+Killer
+Kilogram
+King
+Kitchen
+Kite
+Knee
+Kneel
+Knife
+Knight
+Koala
+Lace
+Ladder
+Ladybug
+Lag
+Landfill
+Lap
+Laugh
+Laundry
+Law
+Lawn
+Lawnmower
+Leak
+Leg
+Letter
+Level
+Lifestyle
+Ligament
+Light
+Lightsaber
+Lime
+Lion
+Lizard
+Log
+Loiterer
+Lollipop
+Loveseat
+Loyalty
+Lunch
+Lunchbox
+Lyrics
+Machine
+Macho
+Mailbox
+Mammoth
+Mark
+Mars
+Mascot
+Mast
+Matchstick
+Mate
+Mattress
+Mess
+Mexico
+Midsummer
+Mine
+Mistake
+Modern
+Mold
+Mom
+Monday
+Money
+Monitor
+Monster
+Mooch
+Moon
+Mop
+Moth
+Motorcycle
+Mountain
+Mouse
+Mower
+Mud
+Music
+Mute
+Nature
+Negotiate
+Neighbor
+Nest
+Neutron
+Niece
+Night
+Nightmare
+Nose
+Oar
+Observatory
+Office
+Oil
+Old
+Olympian
+Opaque
+Opener
+Orbit
+Organ
+Organize
+Outer
+Outside
+Ovation
+Overture
+Pail
+Paint
+Pajamas
+Palace
+Pants
+Paper
+Paper
+Park
+Parody
+Party
+Password
+Pastry
+Pawn
+Pear
+Pen
+Pencil
+Pendulum
+Penis
+Penny
+Pepper
+Personal
+Philosopher
+Phone
+Photograph
+Piano
+Picnic
+Pigpen
+Pillow
+Pilot
+Pinch
+Ping
+Pinwheel
+Pirate
+Plaid
+Plan
+Plank
+Plate
+Platypus
+Playground
+Plow
+Plumber
+Pocket
+Poem
+Point
+Pole
+Pomp
+Pong
+Pool
+Popsicle
+Population
+Portfolio
+Positive
+Post
+Princess
+Procrastinate
+Protestant
+Psychologist
+Publisher
+Punk
+Puppet
+Puppy
+Push
+Puzzle
+Quarantine
+Queen
+Quicksand
+Quiet
+Race
+Radio
+Raft
+Rag
+Rainbow
+Rainwater
+Random
+Ray
+Recycle
+Red
+Regret
+Reimbursement
+Retaliate
+Rib
+Riddle
+Rim
+Rink
+Roller
+Room
+Rose
+Round
+Roundabout
+Rung
+Runt
+Rut
+Sad
+Safe
+Salmon
+Salt
+Sandbox
+Sandcastle
+Sandwich
+Sash
+Satellite
+Scar
+Scared
+School
+Scoundrel
+Scramble
+Scuff
+Seashell
+Season
+Sentence
+Sequins
+Set
+Shaft
+Shallow
+Shampoo
+Shark
+Sheep
+Sheets
+Sheriff
+Shipwreck
+Shirt
+Shoelace
+Short
+Shower
+Shrink
+Sick
+Siesta
+Silhouette
+Singer
+Sip
+Skate
+Skating
+Ski
+Slam
+Sleep
+Sling
+Slow
+Slump
+Smith
+Sneeze
+Snow
+Snuggle
+Song
+Space
+Spare
+Speakers
+Spider
+Spit
+Sponge
+Spool
+Spoon
+Spring
+Sprinkler
+Spy
+Square
+Squint
+Stairs
+Standing
+Star
+State
+Stick
+Stockholder
+Stoplight
+Stout
+Stove
+Stowaway
+Straw
+Stream
+Streamline
+Stripe
+Student
+Sun
+Sunburn
+Sushi
+Swamp
+Swarm
+Sweater
+Swimming
+Swing
+Tachometer
+Talk
+Taxi
+Teacher
+Teapot
+Teenager
+Telephone
+Ten
+Tennis
+Thief
+Think
+Throne
+Through
+Thunder
+Tide
+Tiger
+Time
+Tinting
+Tiptoe
+Tiptop
+Tired
+Tissue
+Toast
+Toilet
+Tool
+Toothbrush
+Tornado
+Tournament
+Tractor
+Train
+Trash
+Treasure
+Tree
+Triangle
+Trip
+Truck
+Tub
+Tuba
+Tutor
+Television
+Twang
+Twig
+Twitterpated
+Type
+Unemployed
+Upgrade
+Vest
+Vision
+Wag
+Water
+Watermelon
+Wax
+Wedding
+Weed
+Welder
+Whatever
+Wheelchair
+Whiplash
+Whisk
+Whistle
+White
+Wig
+Will
+Windmill
+Winter
+Wish
+Wolf
+Wool
+World
+Worm
+Wristwatch
+Yardstick
+Zamboni
+Zen
+Zero
+Zipper
+Zone
+Zoo
diff --git a/games/codenames/server/assets/wordlists/ru.txt b/games/codenames/server/assets/wordlists/ru.txt
new file mode 100644
index 00000000..0d97f435
--- /dev/null
+++ b/games/codenames/server/assets/wordlists/ru.txt
@@ -0,0 +1,191 @@
+рука
+друг
+глаз
+голова
+ребёнок
+сила
+отец
+проблема
+голос
+ночь
+свет
+душа
+минута
+язык
+любовь
+президент
+стена
+интерес
+лес
+игра
+кровь
+картина
+доллар
+музыка
+писатель
+самолёт
+берег
+песня
+круг
+поэт
+сон
+удар
+линия
+доктор
+художник
+волос
+ветер
+грудь
+сад
+камень
+река
+сфера
+воля
+снег
+деревня
+немец
+победа
+звезда
+карман
+кухня
+зуб
+актёр
+чёрт
+дед
+чай
+зима
+студент
+секунда
+бабушка
+трубка
+газ
+улыбка
+май
+остров
+волна
+птица
+тень
+ужас
+декабрь
+цветок
+весна
+трава
+князь
+рыбка
+дождь
+лоб
+восток
+тишина
+подарок
+царь
+смех
+стакан
+экран
+парк
+страсть
+формула
+мост
+лев
+корень
+буква
+лёд
+цифра
+полоса
+куст
+кость
+ручка
+металл
+поэзия
+краска
+мечта
+почва
+король
+шанс
+сумка
+песок
+сказка
+хозяйка
+дочка
+танец
+пенсия
+пыль
+москвич
+корова
+Париж
+туфля
+трамвай
+кошка
+поезд
+щётка
+Бразилия
+тарелка
+Лондон
+лопата
+слон
+Китай
+крыша
+пират
+ящик
+Африка
+посол
+бутылка
+замок
+пилот
+веер
+пальма
+мышь
+луна
+кровать
+день
+кит
+градус
+принцесса
+спутник
+батарея
+няня
+вишня
+арбуз
+заяц
+лиса
+крест
+нож
+Кремль
+книга
+торт
+стул
+клоун
+шоколад
+банан
+конфетка
+куб
+туман
+лягушка
+мамонт
+матрёшка
+лимон
+клубничка
+муза
+нос
+бумага
+радуга
+рояль
+салат
+роза
+шарф
+паук
+тигр
+трактор
+мельница
+свадьба
+водка
+ключ
+Техас
+Испания
+крокодил
+медведь
+верблюд
+динозавр
+леопард
+панда
+зебра
+Венера
diff --git a/games/codenames/server/src/codenames.cpp b/games/codenames/server/src/codenames.cpp
new file mode 100644
index 00000000..b003a29b
--- /dev/null
+++ b/games/codenames/server/src/codenames.cpp
@@ -0,0 +1,140 @@
+#include "cavoke.h"
+#include "model.h"
+#include "wordlists.h"
+
+const int MAX_PLAYERS = 6;
+const std::vector<int> BLUE_PLAYERS = {0, 2, 4};  // NOLINT(cert-err58-cpp)
+const std::vector<int> RED_PLAYERS = {1, 3, 5};   // NOLINT(cert-err58-cpp)
+
+// 0 - blue captain
+// 1 - red captain
+// 2, 4 - blue team
+// 3, 5 - red team
+// requires 0, 1, (2 or 4), (3 or 5)
+bool cavoke::validate_settings(
+    const cavoke::json &settings,
+    const std::vector<int> &occupied_positions,
+    const std::function<void(std::string)> &message_callback) {
+    if (!settings.contains("board_h") || !settings.contains("board_w") ||
+        !settings.contains("word_list") || settings["board_h"].get<int>() < 5 ||
+        settings["board_w"].get<int>() < 4) {
+        message_callback("Invalid config");
+        return false;
+    }
+
+    try {
+        codenames::WordList wl(settings["word_list"].get<std::string>());
+    } catch (const codenames::WordList::wordlist_not_found &e) {
+        message_callback(e.what());
+        return false;
+    }
+
+    auto occupied_end = occupied_positions.end();
+    if (std::find(occupied_positions.begin(), occupied_positions.end(), 0) ==
+        occupied_end) {
+        message_callback("No blue captain");
+        return false;
+    }
+
+    if (std::find(occupied_positions.begin(), occupied_positions.end(), 1) ==
+        occupied_end) {
+        message_callback("No red captain");
+        return false;
+    }
+
+    if (std::find(occupied_positions.begin(), occupied_positions.end(), 2) ==
+            occupied_end &&
+        std::find(occupied_positions.begin(), occupied_positions.end(), 4) ==
+            occupied_end) {
+        message_callback("No blue team");
+        return false;
+    }
+
+    if (std::find(occupied_positions.begin(), occupied_positions.end(), 3) ==
+            occupied_end &&
+        std::find(occupied_positions.begin(), occupied_positions.end(), 5) ==
+            occupied_end) {
+        message_callback("No red team");
+        return false;
+    }
+
+    return true;
+}
+
+cavoke::GameState model_to_game_state(const codenames::CodenamesModel &model) {
+    cavoke::GameState result;
+    result.is_terminal =
+        (model.result() != codenames::CodenamesModel::GAME_RESULT::IN_PROGRESS);
+
+    if (result.is_terminal) {
+        if (model.result() ==
+            codenames::CodenamesModel::GAME_RESULT::BLUE_WINS) {
+            result.winners = BLUE_PLAYERS;
+        } else {
+            result.winners = RED_PLAYERS;
+        }
+    }
+
+    result.global_state = model.get_global_state();
+    result.players_state.resize(MAX_PLAYERS);
+
+    for (int i = 0; i < MAX_PLAYERS; ++i) {
+        result.players_state[i] = model.get_player_state(i);
+    }
+
+    return result;
+}
+
+cavoke::GameState cavoke::init_state(
+    const cavoke::json &settings,
+    const std::vector<int> &occupied_positions) {
+    codenames::CodenamesModel model(
+        settings["board_h"].get<int>(), settings["board_w"].get<int>(),
+        codenames::WordList(settings["word_list"].get<std::string>()));
+
+    return model_to_game_state(model);
+}
+
+bool is_right_player(const codenames::CodenamesModel &model, int player_id) {
+    return ((player_id == 2 || player_id == 4) &&
+            model.stage() ==
+                codenames::CodenamesModel::GAME_STAGE::BLUE_TEAM) ||
+           ((player_id == 3 || player_id == 5) &&
+            model.stage() == codenames::CodenamesModel::GAME_STAGE::RED_TEAM);
+}
+
+bool is_right_captain(const codenames::CodenamesModel &model, int player_id) {
+    return (player_id == 0 &&
+            model.stage() ==
+                codenames::CodenamesModel::GAME_STAGE::BLUE_CAPTAIN) ||
+           (player_id == 1 &&
+            model.stage() ==
+                codenames::CodenamesModel::GAME_STAGE::RED_CAPTAIN);
+}
+
+cavoke::GameState cavoke::apply_move(cavoke::GameMove &new_move) {
+    codenames::CodenamesModel model =
+        nlohmann::json::parse(new_move.global_state);
+    auto command = nlohmann::json::parse(new_move.move);
+    auto type = command["type"].get<std::string>();
+
+    if (type == "hint") {
+        auto hint = command["hint"].get<std::string>();
+        auto attempts = command["attempts"].get<int>();
+
+        if (is_right_captain(model, new_move.player_id)) {
+            model.make_hint(hint, attempts);
+        }
+    } else if (type == "open") {
+        auto pos = command["position"].get<int>();
+        if (is_right_player(model, new_move.player_id)) {
+            model.open_card(pos);
+        }
+    } else if (type == "skip") {
+        if (is_right_player(model, new_move.player_id)) {
+            model.skip();
+        }
+    }
+
+    return model_to_game_state(model);
+}
diff --git a/games/codenames/server/src/model.cpp b/games/codenames/server/src/model.cpp
new file mode 100644
index 00000000..055485e3
--- /dev/null
+++ b/games/codenames/server/src/model.cpp
@@ -0,0 +1,183 @@
+#include "model.h"
+#include <utility>
+
+namespace codenames {
+
+CodenamesModel::GAME_STAGE CodenamesModel::stage() const {
+    return m_stage;
+}
+
+CodenamesModel::GAME_RESULT CodenamesModel::result() const {
+    return m_result;
+}
+
+CodenamesModel::CodenamesModel(int height_,
+                               int width_,
+                               const WordList &wordlist_)
+    : m_height(height_),
+      m_width(width_),
+      m_stage(GAME_STAGE::BLUE_CAPTAIN),
+      m_result(GAME_RESULT::IN_PROGRESS) {
+    int cards_cnt = height_ * width_;
+    m_opened = std::vector<bool>(cards_cnt, false);
+    m_words = wordlist_.sample(cards_cnt);
+    generate_cards();
+}
+
+void CodenamesModel::generate_cards() {
+    std::mt19937 rnd{std::random_device{}()};
+
+    int red_cnt = m_height * m_width / 3;
+    int blue_cnt = red_cnt + 1;
+    int black_cnt = m_height * m_width / 15;
+
+    m_blue_closed = blue_cnt;
+    m_red_closed = red_cnt;
+
+    m_card_states =
+        std::vector<CARD_STATE>(m_height * m_width, CARD_STATE::NEUTRAL);
+
+    for (int i = 0; i < red_cnt; ++i) {
+        size_t pos = rnd() % m_card_states.size();
+        while (m_card_states[pos] != CARD_STATE::NEUTRAL) {
+            pos = rnd() % m_card_states.size();
+        }
+        m_card_states[pos] = CARD_STATE::RED;
+    }
+
+    for (int i = 0; i < blue_cnt; ++i) {
+        size_t pos = rnd() % m_card_states.size();
+        while (m_card_states[pos] != CARD_STATE::NEUTRAL) {
+            pos = rnd() % m_card_states.size();
+        }
+        m_card_states[pos] = CARD_STATE::BLUE;
+    }
+
+    for (int i = 0; i < black_cnt; ++i) {
+        size_t pos = rnd() % m_card_states.size();
+        while (m_card_states[pos] != CARD_STATE::NEUTRAL) {
+            pos = rnd() % m_card_states.size();
+        }
+        m_card_states[pos] = CARD_STATE::BLACK;
+    }
+}
+
+std::string CodenamesModel::get_global_state() const {
+    nlohmann::json state_json = *this;
+    return state_json.dump();
+}
+
+std::string CodenamesModel::get_player_state(int player) const {
+    nlohmann::json result = *this;
+    result["role"] = player;
+    if (player == 0 || player == 1) {
+        return result.dump();
+    }
+
+    result.erase("m_opened");
+
+    std::vector<CARD_STATE> state(m_width * m_height);
+
+    for (int i = 0; i < m_height * m_width; ++i) {
+        if (m_opened[i]) {
+            state[i] = m_card_states[i];
+        } else {
+            state[i] = CARD_STATE::CLOSED;
+        }
+    }
+
+    result["m_card_states"] = std::move(state);
+
+    return result.dump();
+}
+
+void CodenamesModel::open_card(int pos) {
+    if (m_stage == GAME_STAGE::BLUE_CAPTAIN ||
+        m_stage == GAME_STAGE::RED_CAPTAIN) {
+        throw invalid_move();
+    }
+
+    if (m_opened[pos]) {
+        return;
+    }
+
+    m_opened[pos] = true;
+    m_attempts_left--;
+
+    if (m_card_states[pos] == CARD_STATE::BLACK) {
+        m_last_hint = "";
+
+        if (m_stage == GAME_STAGE::BLUE_TEAM) {
+            m_result = GAME_RESULT::RED_WINS;
+        } else {
+            m_result = GAME_RESULT::BLUE_WINS;
+        }
+        m_stage = GAME_STAGE::FINISHED;
+        return;
+
+    } else if (m_card_states[pos] == CARD_STATE::NEUTRAL ||
+               m_attempts_left == 0 ||
+               (m_card_states[pos] == CARD_STATE::BLUE &&
+                m_stage == GAME_STAGE::RED_TEAM) ||
+               (m_card_states[pos] == CARD_STATE::RED &&
+                m_stage == GAME_STAGE::BLUE_TEAM)) {
+        m_last_hint = "";
+        next_stage();
+    }
+
+    if (m_card_states[pos] == CARD_STATE::BLUE) {
+        m_blue_closed--;
+    } else if (m_card_states[pos] == CARD_STATE::RED) {
+        m_red_closed--;
+    }
+
+    if (m_red_closed == 0) {
+        m_result = GAME_RESULT::RED_WINS;
+        m_stage = GAME_STAGE::FINISHED;
+    } else if (m_blue_closed == 0) {
+        m_result = GAME_RESULT::BLUE_WINS;
+        m_stage = GAME_STAGE::FINISHED;
+    }
+}
+
+void CodenamesModel::make_hint(std::string hint, int attempts) {
+    if (m_stage != GAME_STAGE::BLUE_CAPTAIN &&
+        m_stage != GAME_STAGE::RED_CAPTAIN) {
+        throw invalid_move();
+    }
+
+    m_last_hint = std::move(hint);
+    m_attempts_left = attempts + 1;
+
+    next_stage();
+}
+
+void CodenamesModel::skip() {
+    if (m_stage == GAME_STAGE::BLUE_CAPTAIN ||
+        m_stage == GAME_STAGE::RED_CAPTAIN) {
+        throw invalid_move();
+    }
+
+    m_attempts_left = 0;
+    m_last_hint = "";
+
+    next_stage();
+}
+
+void CodenamesModel::next_stage() {
+    if (m_stage == GAME_STAGE::BLUE_CAPTAIN) {
+        m_stage = GAME_STAGE::BLUE_TEAM;
+    } else if (m_stage == GAME_STAGE::BLUE_TEAM) {
+        m_stage = GAME_STAGE::RED_CAPTAIN;
+    } else if (m_stage == GAME_STAGE::RED_CAPTAIN) {
+        m_stage = GAME_STAGE::RED_TEAM;
+    } else if (m_stage == GAME_STAGE::RED_TEAM) {
+        m_stage = GAME_STAGE::BLUE_CAPTAIN;
+    }
+}
+
+CodenamesModel::invalid_move::invalid_move()
+    : std::runtime_error("Invalid move") {
+}
+
+}  // namespace codenames
diff --git a/games/codenames/server/src/model.h b/games/codenames/server/src/model.h
new file mode 100644
index 00000000..26f7227f
--- /dev/null
+++ b/games/codenames/server/src/model.h
@@ -0,0 +1,84 @@
+#ifndef CAVOKE_MODEL_H
+#define CAVOKE_MODEL_H
+
+#include <nlohmann/json.hpp>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include "wordlists.h"
+
+namespace codenames {
+
+class CodenamesModel {  // NOLINT(cppcoreguidelines-pro-type-member-init)
+public:
+    struct invalid_move : std::runtime_error {
+        invalid_move();
+    };
+
+    enum class GAME_STAGE {
+        BLUE_CAPTAIN = 0,
+        BLUE_TEAM = 1,
+        RED_CAPTAIN = 2,
+        RED_TEAM = 3,
+        FINISHED = 4
+    };
+
+    enum class CARD_STATE {
+        BLUE = 0,
+        RED = 1,
+        BLACK = 2,
+        NEUTRAL = 3,
+        CLOSED = 4
+    };
+
+    enum class GAME_RESULT { IN_PROGRESS = 0, BLUE_WINS = 1, RED_WINS = 2 };
+
+private:
+    void generate_cards();
+
+    GAME_STAGE m_stage;
+    std::string m_last_hint;
+    int m_attempts_left = 0;
+    std::vector<std::string> m_words;
+    std::vector<CARD_STATE> m_card_states;
+    std::vector<bool> m_opened;
+    int m_height;
+    int m_width;
+    int m_blue_closed = 0;
+    int m_red_closed = 0;
+    GAME_RESULT m_result;
+
+    void next_stage();
+
+public:
+    [[nodiscard]] GAME_STAGE stage() const;
+    [[nodiscard]] GAME_RESULT result() const;
+
+    void open_card(int pos);
+    void make_hint(std::string hint, int attempts);
+    void skip();
+
+    [[nodiscard]] std::string get_player_state(int player) const;
+    [[nodiscard]] std::string get_global_state() const;
+
+    // cppcheck-suppress unknownMacro
+    NLOHMANN_DEFINE_TYPE_INTRUSIVE(CodenamesModel,
+                                   m_stage,
+                                   m_last_hint,
+                                   m_attempts_left,
+                                   m_words,
+                                   m_card_states,
+                                   m_opened,
+                                   m_height,
+                                   m_width,
+                                   m_result,
+                                   m_blue_closed,
+                                   m_red_closed)
+
+    CodenamesModel(int height_, int width_, const WordList &wordlist_);
+    CodenamesModel() = default;
+};
+
+}  // namespace codenames
+
+#endif  // CAVOKE_MODEL_H
diff --git a/games/codenames/server/src/wordlists.cpp b/games/codenames/server/src/wordlists.cpp
new file mode 100644
index 00000000..02dacdce
--- /dev/null
+++ b/games/codenames/server/src/wordlists.cpp
@@ -0,0 +1,42 @@
+#include "wordlists.h"
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <functional>
+#include <iostream>
+
+namespace codenames {
+
+WordList::wordlist_not_found::wordlist_not_found(const std::string &wordlist)
+    : std::runtime_error("Wordlist \"" + wordlist + "\" not found") {
+}
+
+WordList::WordList(const std::string &wordlist_name)
+    : m_rnd{std::random_device{}()} {
+    std::string file_path =
+        WORDLISTS_PATH + path_sep() + wordlist_name + ".txt";
+    if (!std::filesystem::exists(file_path)) {
+        throw wordlist_not_found(wordlist_name);
+    }
+    std::string word;
+    std::ifstream input(file_path);
+    while (input >> word) {
+        m_words.push_back(word);
+    }
+}
+
+const std::vector<std::string> &WordList::all_words() const {
+    return m_words;
+}
+
+int WordList::size() const {
+    return static_cast<int>(m_words.size());
+}
+
+std::vector<std::string> WordList::sample(int n) const {
+    std::vector<std::string> result(n);
+    std::sample(m_words.begin(), m_words.end(), result.begin(), n, m_rnd);
+    return result;
+}
+
+}  // namespace codenames
diff --git a/games/codenames/server/src/wordlists.h b/games/codenames/server/src/wordlists.h
new file mode 100644
index 00000000..1f78d77c
--- /dev/null
+++ b/games/codenames/server/src/wordlists.h
@@ -0,0 +1,37 @@
+#ifndef CAVOKE_WORDLISTS_H
+#define CAVOKE_WORDLISTS_H
+
+#include <filesystem>
+#include <random>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+namespace codenames {
+
+inline std::string path_sep() {
+    return {std::filesystem::path::preferred_separator};
+}
+
+// NOLINTNEXTLINE(cert-err58-cpp)
+const std::string WORDLISTS_PATH = "assets" + path_sep() + "wordlists";
+
+struct WordList {
+    explicit WordList(const std::string &wordlist_name);
+
+    struct wordlist_not_found : std::runtime_error {
+        explicit wordlist_not_found(const std::string &wordlist);
+    };
+
+    [[nodiscard]] const std::vector<std::string> &all_words() const;
+    [[nodiscard]] int size() const;
+    [[nodiscard]] std::vector<std::string> sample(int n) const;
+
+private:
+    std::vector<std::string> m_words;
+    mutable std::mt19937 m_rnd;
+};
+
+}  // namespace codenames
+
+#endif  // CAVOKE_WORDLISTS_H
diff --git a/games/tictactoe/tictactoe.cpp b/games/tictactoe/tictactoe.cpp
index db2fd9f7..9c877181 100644
--- a/games/tictactoe/tictactoe.cpp
+++ b/games/tictactoe/tictactoe.cpp
@@ -1,5 +1,5 @@
 #include <sstream>
-#include "../cavoke.h"
+#include "cavoke.h"
 
 namespace cavoke {
 
@@ -30,7 +30,7 @@ int get_board_size(const std::string &board) {
     return static_cast<int>(sqrt(static_cast<double>(board.size())));
 }
 
-char current_player(std::string &board) {
+char current_player(const std::string &board) {
     int xs_cnt = 0;
     int os_cnt = 0;
     for (int i = 0; i < board.size(); ++i) {
@@ -44,7 +44,7 @@ char current_player(std::string &board) {
     return (xs_cnt == os_cnt ? 'X' : 'O');
 }
 
-int extract_position(std::string &move) {
+int extract_position(const std::string &move) {
     std::stringstream to_split(move);
     char action;
     to_split >> action;
@@ -53,10 +53,15 @@ int extract_position(std::string &move) {
     return position;
 };
 
-bool is_valid_move(std::string &board, int position) {
+bool is_valid_move(const std::string &board, int position) {
     return position >= 0 && position < board.size() && board[position] == ' ';
 }
 
+bool is_full(const std::string &board) {
+    return std::none_of(board.begin(), board.end(),
+                        [](char c) { return c == ' '; });
+}
+
 int coord_to_pos(int x, int y, int board_size) {
     return x * board_size + y;
 }
@@ -158,12 +163,13 @@ GameState apply_move(GameMove &new_move) {
 
     board[position] = player;
     bool win = winner(board);
+    bool full = is_full(board);
 
     std::vector<int> winners;
     if (win) {
         winners.push_back(new_move.player_id);
     }
 
-    return {win, board, {board, board}, winners};
+    return {win || full, board, {board, board}, winners};
 }
 }  // namespace cavoke
diff --git a/install-karchive.sh b/install-karchive.sh
new file mode 100755
index 00000000..f9205924
--- /dev/null
+++ b/install-karchive.sh
@@ -0,0 +1,10 @@
+#!/usr/bin/env sh
+mkdir build-zlib
+cmake -B build-zlib ./third_party/zlib
+cmake --build build-zlib --target install
+mkdir build-ECM
+cmake -B build-ECM ./third_party/extra-cmake-modules
+cmake --build build-ECM --target install
+mkdir build-karchive
+cmake -B build-karchive ./third_party/karchive
+cmake --build build-karchive --target install
\ No newline at end of file
diff --git a/server.Dockerfile b/server.Dockerfile
new file mode 100644
index 00000000..ddf4a509
--- /dev/null
+++ b/server.Dockerfile
@@ -0,0 +1,21 @@
+FROM ghcr.io/cavoke-project/cavoke-ci:server
+
+# Build arguments. Use `--build-arg` in docker run
+ARG SERVER_PORT=8080
+
+EXPOSE $SERVER_PORT
+
+# Cavoke server
+ENV CAVOKE_ROOT="$IROOT/cavoke/"
+ADD ./ $CAVOKE_ROOT
+# add cavoke-dev-lib dependency
+ADD cavoke-dev-lib/ $CAVOKE_ROOT
+WORKDIR $CAVOKE_ROOT
+# Install server
+RUN mkdir -p build && \
+    cmake . -B build -DBUILD_ALL=OFF -DBUILD_SERVER=ON -DUSE_EXTERNAL_DROGON=ON -DUSE_EXTERNAL_NLOHMANN=ON -DUSE_EXTERNAL_JWT=ON && \
+    make -C build install
+WORKDIR /
+RUN rm -rf $CAVOKE_ROOT
+
+ENTRYPOINT ["/usr/local/bin/cavoke_server"]
diff --git a/server/.gcp/Dockerfile b/server/.gcp/Dockerfile
new file mode 100644
index 00000000..74d4ce4c
--- /dev/null
+++ b/server/.gcp/Dockerfile
@@ -0,0 +1,38 @@
+FROM ghcr.io/cavoke-project/cavoke-server
+
+# Install system dependencies
+RUN set -e; \
+    apt-get update -y && apt-get install -y \
+    tini \
+    lsb-release \
+    gpg-agent; \
+    gcsFuseRepo=gcsfuse-`lsb_release -c -s`; \
+    echo "deb http://packages.cloud.google.com/apt $gcsFuseRepo main" | \
+    tee /etc/apt/sources.list.d/gcsfuse.list; \
+    curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | \
+    apt-key add -; \
+    apt-get update; \
+    apt-get install -y gcsfuse \
+    && apt-get clean
+
+# Drogon configuration basename for
+ARG DROGON_CONFIG_BASENAME=drogon_config.json
+
+# Set fallback mount directory
+ENV MNT_DIR /mnt/gcs
+ENV DROGON_CONFIG_FILE $MNT_DIR/$DROGON_CONFIG_BASENAME
+
+# Copy local code to the container image.
+ENV APP_HOME /app
+WORKDIR $APP_HOME
+COPY gcsfuse_run.sh ./
+
+# Ensure the script is executable
+RUN chmod +x /app/gcsfuse_run.sh
+
+# Use tini to manage zombie processes and signal forwarding
+# https://github.com/krallin/tini
+ENTRYPOINT ["/usr/bin/tini", "--"]
+
+# Pass the startup script as arguments to Tini
+CMD ["/app/gcsfuse_run.sh"]
\ No newline at end of file
diff --git a/server/.gcp/gcsfuse_run.sh b/server/.gcp/gcsfuse_run.sh
new file mode 100644
index 00000000..0f3dda09
--- /dev/null
+++ b/server/.gcp/gcsfuse_run.sh
@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+# Create mount directory for service
+mkdir -p "$MNT_DIR"
+
+echo "Mounting GCS Fuse."
+gcsfuse --debug_gcs --debug_fuse --file-mode=777 "$BUCKET" "$MNT_DIR"
+echo "Mounting completed."
+
+# Run the web service on container startup.
+exec /usr/local/bin/cavoke_server -p "$PORT" -c "$DROGON_CONFIG_FILE" "$@" &
+
+# Exit immediately when one of the background processes terminate.
+wait -n
\ No newline at end of file
diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt
index d240d42c..86fa7004 100644
--- a/server/CMakeLists.txt
+++ b/server/CMakeLists.txt
@@ -1,35 +1,85 @@
 cmake_minimum_required(VERSION 3.10)
 project(cavoke_server)
-
 set(CMAKE_CXX_STANDARD 17)
 
-find_package(Drogon 1.7.3 REQUIRED)
-
-find_package(Boost 1.71 REQUIRED filesystem program_options)
-include_directories(${Boost_INCLUDE_DIRS})
-link_directories(${Boost_LIBRARY_DIRS})
+set(CAVOKE_H_DIR ../cavoke-dev-lib CACHE PATH "Directory with cavoke.h library")
+include_directories(${CAVOKE_H_DIR})
 
-# https://github.com/nlohmann/json/releases/tag/v3.9.0 for convenience macros
-find_package(nlohmann_json 3.9.0 REQUIRED)
+aux_source_directory(model SRC_DIR)
+aux_source_directory(controllers CTL_SRC)
+aux_source_directory(filters FILTER_SRC)
+aux_source_directory(plugins PLUGIN_SRC)
+aux_source_directory(sql-models MODEL_SRC)
 
-include_directories(.)
+# C++ namespace with sql models drogon ORM
+add_compile_definitions(cavoke_orm=cavoke)
 
-add_executable(cavoke_server
+add_executable(${PROJECT_NAME}
         main.cpp
-        model/games_storage.cpp
-        model/game.cpp
+        cavoke_base_exception.cpp
+        ${FILTER_SRC}
+        ${PLUGIN_SRC}
+        ${MODEL_SRC}
+        model/games/games_storage.cpp
+        model/games/game.cpp
         controllers/games_controller.cpp
         controllers/health_controller.cpp
-        model/games_storage_config.cpp
-        model/game_state_storage.cpp
+        model/games/games_storage_config.cpp
+        model/logic/game_state_storage.cpp
         model/sessions/sessions_storage.cpp
-        model/game_logic_manager.cpp
+        model/logic/game_logic_manager.cpp
         controllers/state_controller.cpp
         controllers/sessions_controller.cpp
-        model/auth/authentication_manager.cpp
+        controllers/users_controller.cpp
         model/sessions/game_session.cpp
-        cavoke_base_exception.cpp
+        model/statistics/statistics_manager.cpp
+        controllers/statistics_controller.cpp
+        model/rooms/rooms_storage.cpp
+        controllers/rooms_controller.cpp
+        controllers/gamesubmissions_controller.cpp
         )
-target_link_libraries(cavoke_server Drogon::Drogon)
-target_link_libraries(cavoke_server ${Boost_LIBRARIES} ${CMAKE_DL_LIBS})
-target_link_libraries(cavoke_server nlohmann_json::nlohmann_json)
+install(TARGETS ${PROJECT_NAME})
+
+find_package(Boost 1.71 REQUIRED filesystem program_options)
+include_directories(${Boost_INCLUDE_DIRS})
+link_directories(${Boost_LIBRARY_DIRS})
+
+# Link Drogon
+if (USE_EXTERNAL_DROGON)
+    target_link_libraries(${PROJECT_NAME} PRIVATE Drogon::Drogon)
+else ()
+    target_link_libraries(${PROJECT_NAME} PRIVATE drogon)
+endif ()
+
+# Link nlohmann
+if (USE_EXTERNAL_NLOHMANN)
+    target_link_libraries(${PROJECT_NAME} PRIVATE nlohmann_json::nlohmann_json)
+else ()
+    target_link_libraries(${PROJECT_NAME} PRIVATE nlohmann_json)
+endif ()
+
+# Link jwt
+if (USE_EXTERNAL_NLOHMANN)
+    target_link_libraries(${PROJECT_NAME} PRIVATE jwt-cpp::jwt-cpp)
+else ()
+    target_link_libraries(${PROJECT_NAME} PRIVATE jwt-cpp)
+endif ()
+
+
+target_link_libraries(cavoke_server PRIVATE ${Boost_LIBRARIES} ${CMAKE_DL_LIBS})
+
+drogon_create_views(${PROJECT_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/views
+        ${CMAKE_CURRENT_BINARY_DIR})
+# use the following line to create views with namespaces.
+# drogon_create_views(${PROJECT_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/views
+#                     ${CMAKE_CURRENT_BINARY_DIR} TRUE)
+
+target_include_directories(${PROJECT_NAME}
+        PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+# ##############################################################################
+# uncomment the following line for dynamically loading views
+# set_property(TARGET ${PROJECT_NAME} PROPERTY ENABLE_EXPORTS ON)
+
+# ##############################################################################
+
+add_subdirectory(test)
diff --git a/server/README.md b/server/README.md
index 0098d2d8..9cedd249 100644
--- a/server/README.md
+++ b/server/README.md
@@ -1,17 +1,133 @@
 # Серверный компонент Cavoke
 
 ## О сервере
+
 TODO
 
 ## Как запустить
-### Установка
-Для работы сервера нужно установить несколько библиотек: 
+
+### Docker
+
+Проще всего сервер запустить внутри docker контейнера.
+
+#### Docker Compose
+
+Для локальной разработки в одну команду можно запустить сервер через docker-compose.
+
+```console
+cavoke@ubuntu:~$ docker-compose up -d
+cavoke@ubuntu:~$ curl -s localhost:8080/games/list
+[{"display_name":"Tic-tac-toe","id":"tictactoe", ... }]
+```
+
+Для этого можно воспользоваться актуальным
+image [`ghcr.io/cavoke-project/cavoke-server`](ghcr.io/cavoke-project/cavoke-server).
+
+#### Пример с mount игр
+
+```console
+cavoke@ubuntu:~$ find . -type f
+./local_games/tictactoe/client.zip
+./local_games/tictactoe/logic
+./local_games/tictactoe/config.json
+cavoke@ubuntu:~$ docker run -v `pwd`/local_games:/mnt/games -p 8080:8080 -d ghcr.io/cavoke-project/cavoke-server -g /mnt/games
+cavoke@ubuntu:~$ curl -s localhost:8080/games/list
+[{"display_name":"Tic-tac-toe","id":"tictactoe", ... }]
+```
+
+<!-- TODO: execution permissions required. Example above will only list games, etc.-->
+
+Подробное описание всех опций запуска см. в `docker run -t ghcr.io/cavoke-project/cavoke-server --help`
+
+### Собрать самому
+
+#### На своей машине
+
+Для сборки необходимо установить [boost](https://www.boost.org/) не старее 1.71, а также несколько пакетов для
+серверного фреймворка.
+
+Например, на ubuntu все зависимости можно загрузить с помощью `apt`.
+
+```console
+cavoke@ubuntu:~$ apt install libboost-all-dev \
+    openssl libssl-dev libjsoncpp-dev uuid-dev zlib1g-dev libc-ares-dev \
+    postgresql-server-dev-all
+```
+
+После этого можно будет собрать проект с помощью `cmake`.
+
+```console
+cavoke@ubuntu:~$ mkdir -p build-cmake && cmake . -B build-cmake
+```
+
+> :information_source: Для сборки, используя локальные библиотеки, может понадобиться
+> прописать `git submodule update --init --recursive` для загрузки подмодулей.
+
+#### Установка библиотек извне
+
+Вообще же на сервере используются следующие библиотеки. Альтернативно можно установить каждую из них отдельно,
+следуя инструкциям в их документации.
+
 - [drogon](https://github.com/drogonframework/drogon) не старее 1.7.3
 - [nlohmann/json](https://github.com/nlohmann/json) не старее 3.9.0
 - [boost](https://www.boost.org/) не старее 1.71
 
-#### Собрать самому
-На своей машине первые две библиотеки проще собрать самому. В nlohmann вообще отсутствуют внешние зависимости. В drogon же их много, поэтому сборка не на linux может быть увлекательным процессом.
+После этого, чтобы указать установку библиотеки cmake, стоит использовать флаг. Например, `-DUSE_EXTERNAL_DROGON=ON`.
+
+Итого команда для запуска `cmake` может выглядеть так:
+
+```console
+cavoke@ubuntu:~$ mkdir -p build-cmake && cmake . -B build-cmake -DUSE_EXTERNAL_DROGON=ON -DUSE_EXTERNAL_NLOHMANN=ON
+```
+
+Более подробно смотрите в [CMakeLists.txt](./CMakeLists.txt)
+
+#### Gitpod
+
+Альтернативно, можно попробовать разрабатывать в удаленной среде. Для этого подключён сервис Gitpod, с помощью которого
+можно в браузере запустить VS Code, в котором уже будут добавлены все зависимости, а работать он будет в облаке.
+
+[![Open in Gitpod](https://gitpod.io/button/open-in-gitpod.svg)](https://gitpod.io/#https://github.com/cavoke-project/cavoke)
+
+### SQL
+
+Для обработки большинства запросов сервера требуется база данных [Postgresql](https://www.postgresql.org/).
+
+После того как сервер postgres запущен, создайте необходимые таблицы с помощью [скрипта sql](db/schema.sql). Например,
+на linux:
+
+```bash
+PGPASSWORD="postgres_password"
+psql -h postgres -d cavoke -U postgres_user -f server/db/schema.sql
+```
+
+После этого нужно обновить ваш конфигурационный файл Drogon ([шаблон конфигурационного файла](./example_config.json)),
+дополнив его информацией о подключении к базе данных.
+
+Для того чтобы передать серверу конфигурационный файл, запустите его с ключом `-c`. Например:
+
+```console
+cavoke@ubuntu:~$ cavoke_server -c my_config.json
+Booting server... at /home/cavoke/build/server/cavoke_server
+Server configuration loaded from: 'my_config.json'
+Initialize models...
+Initialize controllers...
+Database connection: host=127.0.0.1 port=5432 dbname=cavoke user=postgres_user <pass hidden>
+Listening at 0.0.0.0:8080... 
+```
+
+## Разработка
+
+### Drogon ORM
+
+Для работы с базой данных
+используется [Drogon ORM](https://github.com/drogonframework/drogon/wiki/ENG-08-3-DataBase-ORM). Модели находятся в
+директории [sql-models](./sql-models).
+
+Чтобы перегенерировать ORM, стоит воспользоваться утилитой
+[`drogon_ctl`](https://github.com/drogonframework/drogon/wiki/ENG-11-drogon_ctl-Command), которая
+устанавливается вместе с Drogon.
 
-#### Docker
-TODO [track](https://github.com/cavoke-project/cavoke/issues/35)
\ No newline at end of file
+```console
+cavoke@ubuntu:~$ drogon_ctl create model sql-models
+```
\ No newline at end of file
diff --git a/server/cavoke_base_exception.h b/server/cavoke_base_exception.h
index 2c6bdbfc..08343f2e 100644
--- a/server/cavoke_base_exception.h
+++ b/server/cavoke_base_exception.h
@@ -8,7 +8,12 @@ namespace cavoke::server {
 /// Base exception for errors thrown in server
 struct cavoke_base_exception : std::runtime_error {
 public:
-    enum error_code { UnknownError = 0, InvalidClientInput, NotFound };
+    enum error_code {
+        UnknownError = 0,
+        InvalidClientInput,
+        NotFound,
+        InvalidConfig
+    };
 
     cavoke_base_exception(std::string message,
                           error_code code,
diff --git a/server/controllers/games_controller.cpp b/server/controllers/games_controller.cpp
index 75f7ac10..5fce452c 100644
--- a/server/controllers/games_controller.cpp
+++ b/server/controllers/games_controller.cpp
@@ -11,8 +11,8 @@ void cavoke::server::controllers::GamesController::games_list(
     const drogon::HttpRequestPtr &req,
     std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
     std::vector<model::Game> games = m_games_storage->list_games();
-    std::vector<model::GameConfig> configs(games.size());
-    std::transform(games.begin(), games.end(), configs.begin(),
+    std::vector<model::GameConfig> configs;
+    std::transform(games.begin(), games.end(), std::back_inserter(configs),
                    [](const model::Game &g) { return g.config; });
 
     auto resp = newNlohmannJsonResponse(configs);
diff --git a/server/controllers/games_controller.h b/server/controllers/games_controller.h
index cb537624..42f61dec 100644
--- a/server/controllers/games_controller.h
+++ b/server/controllers/games_controller.h
@@ -2,7 +2,7 @@
 #define CAVOKE_SERVER_GAMES_CONTROLLER_H
 
 #include <drogon/HttpController.h>
-#include "../model/games_storage.h"
+#include "model/games/games_storage.h"
 
 namespace cavoke::server::controllers {
 
@@ -13,13 +13,18 @@ class GamesController : public drogon::HttpController<GamesController, false> {
 
 public:
     METHOD_LIST_BEGIN
-    ADD_METHOD_TO(GamesController::games_list, "/games/list", drogon::Get);
+    ADD_METHOD_TO(GamesController::games_list,
+                  "/games/list",
+                  drogon::Get,
+                  drogon::Options);
     ADD_METHOD_TO(GamesController::game_config,
                   "/games/{game_id}/get_config",
-                  drogon::Get);
+                  drogon::Get,
+                  drogon::Options);
     ADD_METHOD_TO(GamesController::game_client_file,
                   "/games/{game_id}/get_client",
-                  drogon::Get);
+                  drogon::Get,
+                  drogon::Options);
     METHOD_LIST_END
 
     explicit GamesController(
diff --git a/server/controllers/gamesubmissions_controller.cpp b/server/controllers/gamesubmissions_controller.cpp
new file mode 100644
index 00000000..136c0de2
--- /dev/null
+++ b/server/controllers/gamesubmissions_controller.cpp
@@ -0,0 +1,56 @@
+#include "gamesubmissions_controller.h"
+#include "filters/AuthFilter.h"
+
+namespace cavoke::server::controllers {
+
+void GameSubmissionsController::submit_game(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    // TODO: Auth. Currently problems with authenticating the form request.
+    // parse web form
+    drogon::MultiPartParser mpp;
+    int res = mpp.parse(req);
+    if (res == -1) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+    // form files
+    auto files = mpp.getFilesMap();
+    // form params
+    nlohmann::json j = mpp.getParameters();
+    if (!j.contains("git_repo")) {
+        j["git_repo"] = "<empty>";
+    }
+    // serialize
+    GameSubmissionReq req_data;
+    try {
+        req_data = j.get<GameSubmissionReq>();
+    } catch (...) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+    // validation
+    if (req_data.package_type != "Git Repository" &&
+        req_data.package_type != "Zip Archive") {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+
+    auto id = drogon::utils::getUuid();
+    auto submission = req_data.to_orm(id);
+    if (req_data.package_type == "Zip Archive") {
+        try {
+            files.at("client_zip").saveAs(id + "-client.zip");
+            files.at("server_zip").saveAs(id + "-server.zip");
+        } catch (...) {
+            return CALLBACK_STATUS_CODE(k400BadRequest);
+        }
+    }
+    // save to db
+    mp_submissions.insert(submission);
+
+    LOG_INFO << "New game submission! Game: " << req_data.display_name;
+    auto resp = newStatusCodeResponse(drogon::k200OK);
+    resp->setBody(
+        "Thanks for your game submission! We will review it and publish your "
+        "game shortly.");
+    return callback(resp);
+}
+}  // namespace cavoke::server::controllers
\ No newline at end of file
diff --git a/server/controllers/gamesubmissions_controller.h b/server/controllers/gamesubmissions_controller.h
new file mode 100644
index 00000000..d2e8d000
--- /dev/null
+++ b/server/controllers/gamesubmissions_controller.h
@@ -0,0 +1,58 @@
+#ifndef CAVOKE_GAMESUBMISSIONS_CONTROLLER_H
+#define CAVOKE_GAMESUBMISSIONS_CONTROLLER_H
+
+#include <drogon/HttpController.h>
+#include <nlohmann/json.hpp>
+#include "sql-models/Gamesubmissions.h"
+#include "utils.h"
+
+namespace cavoke::server::controllers {
+
+class GameSubmissionsController
+    : public drogon::HttpController<GameSubmissionsController, true> {
+public:
+    METHOD_LIST_BEGIN
+    ADD_METHOD_TO(GameSubmissionsController::submit_game,
+                  "/submit_game",
+                  drogon::Post,
+                  drogon::Options);
+    METHOD_LIST_END
+
+    struct GameSubmissionReq {
+        std::string game_id;
+        std::string display_name;
+        std::string description;
+        std::string package_type;
+        std::string git_repo;
+
+        auto to_orm(const std::string &id) {
+            drogon_model::cavoke_orm::Gamesubmissions res;
+            res.setId(id);
+            res.setGameId(game_id);
+            res.setPackageType(package_type);
+            res.setGitRepo(git_repo);
+            res.setDisplayName(display_name);
+            return res;
+        }
+    };
+
+protected:
+    void submit_game(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+
+private:
+    MAPPER_TYPE(drogon_model::cavoke_orm::Gamesubmissions)
+    mp_submissions = MAPPER_FOR(drogon_model::cavoke_orm::Gamesubmissions);
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameSubmissionsController::GameSubmissionReq,
+                                   game_id,
+                                   display_name,
+                                   description,
+                                   package_type,
+                                   git_repo);
+
+}  // namespace cavoke::server::controllers
+
+#endif  // CAVOKE_GAMESUBMISSIONS_CONTROLLER_H
diff --git a/server/controllers/health_controller.h b/server/controllers/health_controller.h
index 5f957e4d..6537d954 100644
--- a/server/controllers/health_controller.h
+++ b/server/controllers/health_controller.h
@@ -8,7 +8,10 @@ namespace cavoke::server::controllers {
 class HealthController : public drogon::HttpController<HealthController, true> {
 public:
     METHOD_LIST_BEGIN
-    ADD_METHOD_TO(HealthController::health, "/health", drogon::Get);
+    ADD_METHOD_TO(HealthController::health,
+                  "/health",
+                  drogon::Get,
+                  drogon::Options);
     METHOD_LIST_END
 
 protected:
diff --git a/server/controllers/rooms_controller.cpp b/server/controllers/rooms_controller.cpp
new file mode 100644
index 00000000..dc950382
--- /dev/null
+++ b/server/controllers/rooms_controller.cpp
@@ -0,0 +1,175 @@
+#include "rooms_controller.h"
+#include <utility>
+#include "filters/AuthFilter.h"
+
+namespace cavoke::server::controllers {
+
+void RoomsController::create_room(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    // get user id
+    auto user_id = AuthFilter::get_user_id(req);
+
+    auto display_name = req->getOptionalParameter<std::string>("display_name");
+    if (!display_name.has_value()) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+
+    auto room = m_rooms_storage->create_room(user_id, display_name.value());
+    return callback(newNlohmannJsonResponse(room));
+}
+
+void RoomsController::create_session(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &room_id) {
+    // get game id
+    auto game_id = req->getOptionalParameter<std::string>("game_id");
+    if (!game_id.has_value()) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+
+    auto room_info = m_rooms_storage->get_by_id(room_id);
+    if (!room_info.has_value()) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
+    }
+
+    // get user id
+    auto user_id = AuthFilter::get_user_id(req);
+
+    if (room_info.value().host_id != user_id) {
+        return CALLBACK_STATUS_CODE(k403Forbidden);
+    }
+
+    auto game = m_games_storage->get_game_by_id(game_id.value());
+    if (!game.has_value()) {
+        return callback(newCavokeErrorResponse(
+            {"game '" + game_id.value() + "' not found",
+             cavoke_base_exception::error_code::NotFound},
+            drogon::k404NotFound));
+    }
+
+    try {
+        auto session =
+            m_rooms_storage->create_session(room_id, game.value().config);
+        return callback(newNlohmannJsonResponse(session));
+    } catch (const model::room_error &e) {
+        return callback(newCavokeErrorResponse(e, k403Forbidden));
+    }
+}
+
+void RoomsController::get_info(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &room_id) {
+    auto room_info = m_rooms_storage->get_by_id(room_id);
+    if (!room_info.has_value()) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
+    }
+
+    if (!room_info->session_id.empty()) {
+        room_info->session =
+            m_sessions_storage->get_sessionAO(room_info->session_id)
+                .get_session_info();
+    }
+    json json_res = room_info.value();
+    if (room_info->session_id.empty()) {
+        json_res.erase("session");
+    }
+
+    return callback(newNlohmannJsonResponse(json_res));
+}
+
+void RoomsController::get_info_by_invite_code(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    auto invite_code = req->getOptionalParameter<std::string>("invite_code");
+    if (!invite_code.has_value()) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+
+    auto room_info = m_rooms_storage->get_by_invite_code(invite_code.value());
+    if (!room_info.has_value()) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
+    }
+
+    if (!room_info->session_id.empty()) {
+        room_info->session =
+            m_sessions_storage->get_sessionAO(room_info->session_id)
+                .get_session_info();
+    }
+    json json_res = room_info.value();
+    if (room_info->session_id.empty()) {
+        json_res.erase("session");
+    }
+
+    return callback(newNlohmannJsonResponse(json_res));
+}
+
+void RoomsController::join(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    auto invite_code = req->getOptionalParameter<std::string>("invite_code");
+    if (!invite_code.has_value()) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+
+    auto room_info = m_rooms_storage->get_by_invite_code(invite_code.value());
+    if (!room_info.has_value()) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
+    }
+
+    // get user id
+    auto user_id = AuthFilter::get_user_id(req);
+
+    try {
+        m_rooms_storage->add_user(room_info.value().room_id, user_id);
+        auto result =
+            m_rooms_storage->get_by_invite_code(invite_code.value()).value();
+        if (!result.session_id.empty()) {
+            result.session =
+                m_sessions_storage->get_sessionAO(result.session_id)
+                    .get_session_info();
+        }
+        json json_res = result;
+        if (result.session_id.empty()) {
+            json_res.erase("session");
+        }
+
+        return callback(newNlohmannJsonResponse(json_res));
+    } catch (const model::room_error &e) {
+        return callback(newCavokeErrorResponse(e, drogon::k404NotFound));
+    }
+}
+
+void RoomsController::leave(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &room_id) {
+    auto room_info = m_rooms_storage->get_by_id(room_id);
+    if (!room_info.has_value()) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
+    }
+
+    // get user id
+    auto user_id = AuthFilter::get_user_id(req);
+
+    try {
+        m_rooms_storage->remove_user(room_id, user_id);
+    } catch (const model::room_error &e) {
+        return callback(newCavokeErrorResponse(e, drogon::k404NotFound));
+    }
+
+    return CALLBACK_STATUS_CODE(k200OK);
+}
+
+RoomsController::RoomsController(
+    std::shared_ptr<model::RoomsStorage> mRoomsStorage,
+    std::shared_ptr<model::GamesStorage> mGamesStorage,
+    std::shared_ptr<model::SessionsStorage> mSessionsStorage)
+    : m_rooms_storage(std::move(mRoomsStorage)),
+      m_games_storage(std::move(mGamesStorage)),
+      m_sessions_storage(std::move(mSessionsStorage)) {
+}
+
+}  // namespace cavoke::server::controllers
diff --git a/server/controllers/rooms_controller.h b/server/controllers/rooms_controller.h
new file mode 100644
index 00000000..5000bf76
--- /dev/null
+++ b/server/controllers/rooms_controller.h
@@ -0,0 +1,75 @@
+#ifndef CAVOKE_ROOMS_CONTROLLER_H
+#define CAVOKE_ROOMS_CONTROLLER_H
+
+#include <drogon/HttpController.h>
+#include "model/rooms/rooms_storage.h"
+
+namespace cavoke::server::controllers {
+
+class RoomsController : public drogon::HttpController<RoomsController, false> {
+    std::shared_ptr<model::RoomsStorage> m_rooms_storage;
+    std::shared_ptr<model::GamesStorage> m_games_storage;
+    std::shared_ptr<model::SessionsStorage> m_sessions_storage;
+
+public:
+    RoomsController(std::shared_ptr<model::RoomsStorage> mRoomsStorage,
+                    std::shared_ptr<model::GamesStorage> mGamesStorage,
+                    std::shared_ptr<model::SessionsStorage> mSessionsStorage);
+
+    METHOD_LIST_BEGIN
+    ADD_METHOD_TO(RoomsController::create_room,
+                  "/rooms/create",
+                  drogon::Post,
+                  "AuthFilter");
+    ADD_METHOD_TO(RoomsController::get_info,
+                  "/rooms/{room_id}/get_info",
+                  drogon::Get,
+                  "AuthFilter");
+    ADD_METHOD_TO(RoomsController::get_info_by_invite_code,
+                  "/rooms/get_info_by_invite_code",
+                  drogon::Get,
+                  "AuthFilter");
+    ADD_METHOD_TO(RoomsController::join,
+                  "/rooms/join",
+                  drogon::Post,
+                  "AuthFilter");
+    ADD_METHOD_TO(RoomsController::leave,
+                  "/rooms/{room_id}/leave",
+                  drogon::Post,
+                  "AuthFilter");
+    ADD_METHOD_TO(RoomsController::create_session,
+                  "/rooms/{room_id}/create_session",
+                  drogon::Post,
+                  "AuthFilter");
+    METHOD_LIST_END
+
+protected:
+    void create_room(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+
+    void create_session(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        const std::string &room_id);
+
+    void get_info(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        const std::string &room_id);
+
+    void get_info_by_invite_code(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+
+    void join(const drogon::HttpRequestPtr &req,
+              std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+
+    void leave(const drogon::HttpRequestPtr &req,
+               std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+               const std::string &room_id);
+};
+
+}  // namespace cavoke::server::controllers
+
+#endif  // CAVOKE_ROOMS_CONTROLLER_H
diff --git a/server/controllers/sessions_controller.cpp b/server/controllers/sessions_controller.cpp
index 857b7b80..64280136 100644
--- a/server/controllers/sessions_controller.cpp
+++ b/server/controllers/sessions_controller.cpp
@@ -1,17 +1,14 @@
 #include "sessions_controller.h"
 
-void cavoke::server::controllers::SessionsController::create(
+namespace cavoke::server::controllers {
+
+using json = nlohmann::json;
+
+void SessionsController::create(
     const drogon::HttpRequestPtr &req,
     std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
     // get user id
-    auto user_id = req->getOptionalParameter<std::string>("user_id");
-    if (!user_id.has_value()) {
-        return CALLBACK_STATUS_CODE(k401Unauthorized);
-    }
-    // verify auth
-    if (!m_authentication_manager->verify_authentication(user_id.value())) {
-        return CALLBACK_STATUS_CODE(k401Unauthorized);
-    }
+    auto user_id = AuthFilter::get_user_id(req);
 
     // get game id
     auto game_id = req->getOptionalParameter<std::string>("game_id");
@@ -28,66 +25,162 @@ void cavoke::server::controllers::SessionsController::create(
     }
 
     // create session and acquire session info
-    model::GameSession::GameSessionInfo session_info;
-    // TODO: do we want `try-catch` or `optional`?
+    model::GameSessionAccessObject::GameSessionInfo session_info;
     try {
         session_info = m_participation_storage->create_session(
-            game.value().config, user_id.value());
+            game.value().config, user_id, "");
     } catch (const model::game_session_error &err) {
         return callback(newCavokeErrorResponse(err, drogon::k400BadRequest));
     }
-
-    // configurate initial state for session
-
-    // TODO: validate settings
-    // TODO: get actual connected players
-    m_game_state_storage->save_state(
-        session_info.session_id,
-        m_game_logic_manager->init_state(
-            game_id.value(), game.value().config.default_settings, {0, 1}));
-
     return callback(newNlohmannJsonResponse(session_info));
 }
-void cavoke::server::controllers::SessionsController::join(
+
+void SessionsController::join(
     const drogon::HttpRequestPtr &req,
-    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &session_id) {
     // get user id
-    auto user_id = req->getOptionalParameter<std::string>("user_id");
-    if (!user_id.has_value()) {
-        return CALLBACK_STATUS_CODE(k401Unauthorized);
-    }
-    // verify auth
-    if (!m_authentication_manager->verify_authentication(user_id.value())) {
-        return CALLBACK_STATUS_CODE(k401Unauthorized);
-    }
-
-    // get invite code
-    auto invite_code = req->getOptionalParameter<std::string>("invite_code");
-    if (!invite_code.has_value()) {
-        return CALLBACK_STATUS_CODE(k400BadRequest);
-    }
+    auto user_id = AuthFilter::get_user_id(req);
 
     // join session and acquire session info
-    model::GameSession::GameSessionInfo session_info;
-    // TODO: do we want `try-catch` or `optional`?
+    model::GameSessionAccessObject::GameSessionInfo session_info;
     try {
         session_info = m_participation_storage->join_session(
-            invite_code.value(), user_id.value());
+            session_id, user_id, req->getOptionalParameter<int>("position"));
     } catch (const model::game_session_error &err) {
         return callback(newCavokeErrorResponse(err, drogon::k400BadRequest));
     }
 
     return callback(newNlohmannJsonResponse(session_info));
 }
-cavoke::server::controllers::SessionsController::SessionsController(
+
+SessionsController::SessionsController(
     std::shared_ptr<model::GamesStorage> mGamesStorage,
     std::shared_ptr<model::GameLogicManager> mGameLogicManager,
     std::shared_ptr<model::GameStateStorage> mGameStateStorage,
-    std::shared_ptr<model::SessionsStorage> mParticipationStorage,
-    std::shared_ptr<model::AuthenticationManager> mAuthenticationManager)
+    std::shared_ptr<model::SessionsStorage> mParticipationStorage)
     : m_games_storage(std::move(mGamesStorage)),
       m_game_logic_manager(std::move(mGameLogicManager)),
       m_game_state_storage(std::move(mGameStateStorage)),
-      m_participation_storage(std::move(mParticipationStorage)),
-      m_authentication_manager(std::move(mAuthenticationManager)) {
+      m_participation_storage(std::move(mParticipationStorage)) {
+}
+
+void SessionsController::validate(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &session_id) {
+    // get user id
+    auto user_id = AuthFilter::get_user_id(req);
+
+    model::GameSessionAccessObject session;
+    try {
+        session = m_participation_storage->get_sessionAO(session_id);
+    } catch (const model::game_session_error &err) {
+        return callback(newCavokeErrorResponse(err, drogon::k404NotFound));
+    }
+
+    if (!session.is_player(user_id)) {
+        return CALLBACK_STATUS_CODE(k403Forbidden);
+    }
+
+    // session does exist
+    json result = m_participation_storage->validate_session(session_id, {});
+    if (result["success"].get<bool>()) {
+        result.erase(result.find("message"));
+    }
+    return callback(newNlohmannJsonResponse(result));
+}
+
+void SessionsController::start(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &session_id) {
+    // get user id
+    auto user_id = AuthFilter::get_user_id(req);
+
+    model::GameSessionAccessObject session;
+    try {
+        session = m_participation_storage->get_sessionAO(session_id);
+    } catch (const model::game_session_error &err) {
+        return callback(newCavokeErrorResponse(err, drogon::k404NotFound));
+    }
+
+    if (!session.is_player(user_id)) {
+        return CALLBACK_STATUS_CODE(k403Forbidden);
+    }
+
+    try {
+        // TODO: get settings from body
+        m_participation_storage->start_session(session_id, {});
+    } catch (const model::validation_error &err) {
+        return callback(newCavokeErrorResponse(err, drogon::k400BadRequest));
+    } catch (const model::game_session_error &err) {
+        return callback(newCavokeErrorResponse(err, drogon::k400BadRequest));
+    }
+
+    return CALLBACK_STATUS_CODE(k200OK);
+}
+
+void SessionsController::get_info(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &session_id) {
+    model::GameSessionAccessObject session;
+    try {
+        session = m_participation_storage->get_sessionAO(session_id);
+    } catch (const model::game_session_error &err) {
+        return callback(newCavokeErrorResponse(err, drogon::k404NotFound));
+    }
+
+    return callback(newNlohmannJsonResponse(session.get_session_info()));
 }
+
+void SessionsController::leave(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &session_id) {
+    // get user id
+    auto user_id = AuthFilter::get_user_id(req);
+
+    model::GameSessionAccessObject session;
+    try {
+        session = m_participation_storage->get_sessionAO(session_id);
+    } catch (const model::game_session_error &err) {
+        return callback(newCavokeErrorResponse(err, drogon::k404NotFound));
+    }
+
+    session.leave_session(user_id);
+
+    return CALLBACK_STATUS_CODE(k200OK);
+}
+
+void SessionsController::change_role(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &session_id) {
+    // get user id
+    auto user_id = AuthFilter::get_user_id(req);
+
+    // get new_role
+    auto new_role = req->getOptionalParameter<int>("new_role");
+    if (!new_role.has_value()) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+
+    model::GameSessionAccessObject session;
+    try {
+        session = m_participation_storage->get_sessionAO(session_id);
+    } catch (const model::game_session_error &err) {
+        return callback(newCavokeErrorResponse(err, drogon::k404NotFound));
+    }
+
+    try {
+        session.set_role(user_id, new_role.value());
+    } catch (model::game_session_error &err) {
+        return callback(newCavokeErrorResponse(err, drogon::k400BadRequest));
+    }
+
+    return CALLBACK_STATUS_CODE(k200OK);
+}
+
+}  // namespace cavoke::server::controllers
diff --git a/server/controllers/sessions_controller.h b/server/controllers/sessions_controller.h
index 4e5a2a0a..00277d25 100644
--- a/server/controllers/sessions_controller.h
+++ b/server/controllers/sessions_controller.h
@@ -2,9 +2,9 @@
 #define CAVOKE_SESSIONS_CONTROLLER_H
 
 #include <drogon/HttpController.h>
-#include "model/auth/authentication_manager.h"
-#include "model/game_logic_manager.h"
-#include "model/games_storage.h"
+#include "filters/AuthFilter.h"
+#include "model/games/games_storage.h"
+#include "model/logic/game_logic_manager.h"
 #include "model/sessions/sessions_storage.h"
 
 namespace cavoke::server::controllers {
@@ -15,20 +15,44 @@ class SessionsController
     std::shared_ptr<model::GameLogicManager> m_game_logic_manager;
     std::shared_ptr<model::GameStateStorage> m_game_state_storage;
     std::shared_ptr<model::SessionsStorage> m_participation_storage;
-    std::shared_ptr<model::AuthenticationManager> m_authentication_manager;
 
 public:
     SessionsController(
         std::shared_ptr<model::GamesStorage> mGamesStorage,
         std::shared_ptr<model::GameLogicManager> mGameLogicManager,
         std::shared_ptr<model::GameStateStorage> mGameStateStorage,
-        std::shared_ptr<model::SessionsStorage> mParticipationStorage,
-        std::shared_ptr<model::AuthenticationManager> mAuthenticationManager);
+        std::shared_ptr<model::SessionsStorage> mParticipationStorage);
 
 public:
     METHOD_LIST_BEGIN
-    ADD_METHOD_TO(SessionsController::create, "/sessions/create", drogon::Post);
-    ADD_METHOD_TO(SessionsController::join, "/sessions/join", drogon::Post);
+    ADD_METHOD_TO(SessionsController::create,
+                  "/sessions/create",
+                  drogon::Post,
+                  "AuthFilter");
+    ADD_METHOD_TO(SessionsController::join,
+                  "/sessions/{session_id}/join",
+                  drogon::Post,
+                  "AuthFilter");
+    ADD_METHOD_TO(SessionsController::leave,
+                  "/sessions/{session_id}/leave",
+                  drogon::Post,
+                  "AuthFilter");
+    ADD_METHOD_TO(SessionsController::change_role,
+                  "/sessions/{session_id}/change_role",
+                  drogon::Post,
+                  "AuthFilter");
+    ADD_METHOD_TO(SessionsController::get_info,
+                  "/sessions/{session_id}/get_info",
+                  drogon::Get,
+                  "AuthFilter");
+    ADD_METHOD_TO(SessionsController::start,
+                  "/sessions/{session_id}/start",
+                  drogon::Post,
+                  "AuthFilter");
+    ADD_METHOD_TO(SessionsController::validate,
+                  "/sessions/{session_id}/validate",
+                  drogon::Post,
+                  "AuthFilter");
     METHOD_LIST_END
 
 protected:
@@ -37,7 +61,31 @@ class SessionsController
         std::function<void(const drogon::HttpResponsePtr &)> &&callback);
 
     void join(const drogon::HttpRequestPtr &req,
-              std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+              std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+              const std::string &session_id);
+
+    void leave(const drogon::HttpRequestPtr &req,
+               std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+               const std::string &session_id);
+
+    void change_role(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        const std::string &session_id);
+
+    void validate(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        const std::string &session_id);
+
+    void start(const drogon::HttpRequestPtr &req,
+               std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+               const std::string &session_id);
+
+    void get_info(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        const std::string &session_id);
 };
 
 }  // namespace cavoke::server::controllers
diff --git a/server/controllers/state_controller.cpp b/server/controllers/state_controller.cpp
index 68d72619..9491760c 100644
--- a/server/controllers/state_controller.cpp
+++ b/server/controllers/state_controller.cpp
@@ -3,57 +3,68 @@
 
 namespace cavoke::server::controllers {
 
+using json = nlohmann::json;
+
 void StateController::send_move(
     const drogon::HttpRequestPtr &req,
     std::function<void(const drogon::HttpResponsePtr &)> &&callback,
     const std::string &session_id) {
-    std::optional<std::string> user_id =
-        req->getOptionalParameter<std::string>("user_id");
-
-    if (!user_id.has_value()) {
-        auto resp = drogon::HttpResponse::newHttpResponse();
-        resp->setStatusCode(drogon::HttpStatusCode::k400BadRequest);
-        callback(resp);
-        return;
-    }
+    // get user id
+    auto user_id = AuthFilter::get_user_id(req);
 
-    // TODO: do we want `try-catch` or `optional`?
-    model::GameSession::GameSessionInfo session_info;
-    int player_id;
+    auto transaction = drogon::app().getDbClient()->newTransaction();
+    model::GameSessionAccessObject session;
     try {
-        auto &session = m_participation_storage->get_session(session_id);
-        session_info = session.get_session_info();
-        player_id = session.get_player_id(user_id.value());
+        session =
+            m_participation_storage->get_sessionAO(session_id, transaction);
     } catch (const model::game_session_error &) {
         return CALLBACK_STATUS_CODE(k400BadRequest);
     }
 
-    // TODO: nlohman/json
-    std::string body(req->getBody());
-    Json::Reader reader;
-    Json::Value json_body;
-    bool valid_json = reader.parse(body, json_body);
-    if (!valid_json || !json_body.isMember("move")) {
-        return CALLBACK_STATUS_CODE(k400BadRequest);
+    int player_id;
+    try {
+        player_id = session.get_player_id(user_id);
+    } catch (const model::game_session_error &) {
+        return CALLBACK_STATUS_CODE(k403Forbidden);
     }
 
-    std::string move = json_body["move"].asString();
+    auto session_info = session.get_session_info();
 
-    std::optional<model::GameStateStorage::GameState> current_state =
-        m_game_state_storage->get_state(session_id);
+    if (session_info.status == model::GameSessionAccessObject::FINISHED) {
+        return CALLBACK_STATUS_CODE(k403Forbidden);
+    }
+    if (session_info.status == model::GameSessionAccessObject::NOT_STARTED) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
+    }
 
-    if (!current_state.has_value()) {
+    json json_body;
+    try {
+        json_body = json::parse(req->getBody());
+    } catch (const json::parse_error &) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+    if (!json_body.contains("move")) {
         return CALLBACK_STATUS_CODE(k400BadRequest);
     }
 
-    if (current_state->is_terminal) {
-        return CALLBACK_STATUS_CODE(k403Forbidden);
+    std::string move = json_body["move"];
+
+    model::GameStateStorage::GameState current_state;
+    try {
+        current_state =
+            m_game_state_storage->get_state(session_id, transaction);
+    } catch (const model::game_state_error &) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
     }
 
-    current_state = m_game_logic_manager->send_move(
-        session_info.game_id, {player_id, move, current_state->global_state});
+    auto next_state = m_game_logic_manager->send_move(
+        session_info.game_id, {player_id, move, current_state.global_state});
 
-    m_game_state_storage->save_state(session_id, current_state.value());
+    m_game_state_storage->save_state(session_id, next_state, transaction);
+
+    if (next_state.is_terminal) {
+        session.finish();
+    }
 
     auto resp = drogon::HttpResponse::newHttpResponse();
     resp->setStatusCode(drogon::HttpStatusCode::k200OK);
@@ -64,39 +75,52 @@ void StateController::get_state(
     const drogon::HttpRequestPtr &req,
     std::function<void(const drogon::HttpResponsePtr &)> &&callback,
     const std::string &session_id) {
-    std::optional<std::string> user_id =
-        req->getOptionalParameter<std::string>("user_id");
-
-    if (!user_id.has_value()) {
-        auto resp = drogon::HttpResponse::newHttpResponse();
-        resp->setStatusCode(drogon::HttpStatusCode::k400BadRequest);
-        callback(resp);
-        return;
+    // get user id
+    auto user_id = AuthFilter::get_user_id(req);
+
+    auto transaction = drogon::app().getDbClient()->newTransaction();
+    model::GameSessionAccessObject session;
+    try {
+        session =
+            m_participation_storage->get_sessionAO(session_id, transaction);
+    } catch (const model::game_session_error &) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
     }
 
-    // TODO: do we want `try-catch` or `optional`?
     int player_id;
     try {
-        player_id = m_participation_storage->get_session(session_id)
-                        .get_player_id(user_id.value());
+        player_id = session.get_player_id(user_id);
     } catch (const model::game_session_error &) {
         return CALLBACK_STATUS_CODE(k403Forbidden);
     }
 
-    auto state = m_game_state_storage->get_player_state(session_id, player_id);
+    auto session_info = session.get_session_info();
 
-    if (!state.has_value()) {
-        auto resp = drogon::HttpResponse::newNotFoundResponse();
-        callback(resp);
-        return;
+    if (session_info.status == model::GameSessionAccessObject::NOT_STARTED) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
     }
 
-    Json::Value resp_json;
-    resp_json["state"] = state.value();
-    resp_json["is_terminal"] =
-        m_game_state_storage->get_state(session_id)->is_terminal;
-    auto resp = drogon::HttpResponse::newHttpJsonResponse(resp_json);
-    resp->setStatusCode(drogon::HttpStatusCode::k200OK);
+    std::string player_state;
+    try {
+        player_state =
+            m_game_state_storage->get_player_state(session_id, player_id);
+    } catch (const model::game_state_error &) {
+    }
+
+    json resp_json;
+    resp_json["state"] = std::move(player_state);
+    auto game_state = m_game_state_storage->get_state(session_id, transaction);
+    resp_json["is_terminal"] = game_state.is_terminal;
+    if (game_state.is_terminal) {
+        std::vector<std::string> winners;
+        for (const auto &e : game_state.winners) {
+            // cppcheck-suppress useStlAlgorithm
+            winners.push_back(session.get_user_id(e));
+        }
+        resp_json["winners"] = winners;
+    }
+
+    auto resp = newNlohmannJsonResponse(resp_json);
     callback(resp);
 }
 
diff --git a/server/controllers/state_controller.h b/server/controllers/state_controller.h
index c21449a8..e15c5922 100644
--- a/server/controllers/state_controller.h
+++ b/server/controllers/state_controller.h
@@ -2,8 +2,9 @@
 #define CAVOKE_STATE_CONTROLLER_H
 
 #include <drogon/HttpController.h>
-#include "../model/game_logic_manager.h"
-#include "../model/games_storage.h"
+#include "filters/AuthFilter.h"
+#include "model/games/games_storage.h"
+#include "model/logic/game_logic_manager.h"
 #include "model/sessions/sessions_storage.h"
 
 namespace cavoke::server::controllers {
@@ -25,10 +26,12 @@ class StateController : public drogon::HttpController<StateController, false> {
     METHOD_LIST_BEGIN
     ADD_METHOD_TO(StateController::send_move,
                   "/play/{session_id}/send_move",
-                  drogon::Post);
+                  drogon::Post,
+                  "AuthFilter");
     ADD_METHOD_TO(StateController::get_state,
                   "/play/{session_id}/get_state",
-                  drogon::Get);
+                  drogon::Get,
+                  "AuthFilter");
     METHOD_LIST_END
 
 protected:
diff --git a/server/controllers/statistics_controller.cpp b/server/controllers/statistics_controller.cpp
new file mode 100644
index 00000000..5ee713cb
--- /dev/null
+++ b/server/controllers/statistics_controller.cpp
@@ -0,0 +1,59 @@
+#include "statistics_controller.h"
+#include "filters/AuthFilter.h"
+
+namespace cavoke::server::controllers {
+
+StatisticsController::StatisticsController(
+    std::shared_ptr<model::GamesStorage> mGamesStorage,
+    std::shared_ptr<model::StatisticsManager> mStatisticsManager)
+    : m_games_storage(std::move(mGamesStorage)),
+      m_statistics_manager(std::move(mStatisticsManager)) {
+}
+
+void StatisticsController::game_statistics(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &game_id) {
+    if (!m_games_storage->get_game_by_id(game_id).has_value()) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
+    }
+
+    return callback(newNlohmannJsonResponse(
+        m_statistics_manager->get_game_statistics(game_id)));
+}
+
+void StatisticsController::user_statistics(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &user_id) {
+    return callback(newNlohmannJsonResponse(
+        m_statistics_manager->get_user_statistics(user_id)));
+}
+
+void StatisticsController::user_game_statistics(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &user_id,
+    const std::string &game_id) {
+    if (!m_games_storage->get_game_by_id(game_id).has_value()) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
+    }
+
+    return callback(newNlohmannJsonResponse(
+        m_statistics_manager->get_user_game_statistics(user_id, game_id)));
+}
+void StatisticsController::my_user_statistics(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    return user_statistics(req, std::move(callback),
+                           AuthFilter::get_user_id(req));
+}
+void StatisticsController::my_user_game_statistics(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+    const std::string &game_id) {
+    return user_game_statistics(req, std::move(callback),
+                                AuthFilter::get_user_id(req), game_id);
+}
+
+}  // namespace cavoke::server::controllers
diff --git a/server/controllers/statistics_controller.h b/server/controllers/statistics_controller.h
new file mode 100644
index 00000000..8bcf9710
--- /dev/null
+++ b/server/controllers/statistics_controller.h
@@ -0,0 +1,71 @@
+#ifndef CAVOKE_STATISTICS_CONTROLLER_H
+#define CAVOKE_STATISTICS_CONTROLLER_H
+
+#include "drogon/HttpController.h"
+#include "model/games/games_storage.h"
+#include "model/statistics/statistics_manager.h"
+
+namespace cavoke::server::controllers {
+
+class StatisticsController
+    : public drogon::HttpController<StatisticsController, false> {
+    std::shared_ptr<model::GamesStorage> m_games_storage;
+    std::shared_ptr<model::StatisticsManager> m_statistics_manager;
+
+public:
+    StatisticsController(
+        std::shared_ptr<model::GamesStorage> mGamesStorage,
+        std::shared_ptr<model::StatisticsManager> mStatisticsManager);
+
+public:
+    METHOD_LIST_BEGIN
+    ADD_METHOD_TO(StatisticsController::game_statistics,
+                  "/statistics/game/{game_id}",
+                  drogon::Get,
+                  drogon::Options);
+    ADD_METHOD_TO(StatisticsController::user_statistics,
+                  "/statistics/user/{user_id}",
+                  drogon::Get);
+    ADD_METHOD_TO(StatisticsController::user_game_statistics,
+                  "/statistics/user/{user_id}/game/{game_id}",
+                  drogon::Get);
+    ADD_METHOD_TO(StatisticsController::my_user_statistics,
+                  "/profile/my_user_statistics",
+                  drogon::Get,
+                  "AuthFilter");
+    ADD_METHOD_TO(StatisticsController::my_user_game_statistics,
+                  "/profile/my_user_game_statistics/{game_id}",
+                  drogon::Get,
+                  "AuthFilter");
+    METHOD_LIST_END
+
+protected:
+    void game_statistics(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        const std::string &game_id);
+
+    void user_statistics(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        const std::string &user_id);
+
+    void user_game_statistics(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        const std::string &user_id,
+        const std::string &game_id);
+
+    void my_user_statistics(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+
+    void my_user_game_statistics(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback,
+        const std::string &game_id);
+};
+
+}  // namespace cavoke::server::controllers
+
+#endif  // CAVOKE_STATISTICS_CONTROLLER_H
diff --git a/server/controllers/users_controller.cpp b/server/controllers/users_controller.cpp
new file mode 100644
index 00000000..aaf2c675
--- /dev/null
+++ b/server/controllers/users_controller.cpp
@@ -0,0 +1,55 @@
+#include "users_controller.h"
+#include "filters/AuthFilter.h"
+#include "model/sessions/game_session.h"
+
+namespace cavoke::server::controllers {
+void UsersController::get_me(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    auto user_id = AuthFilter::get_user_id(req);
+    auto user = mp_users.findByPrimaryKey(user_id);
+    auto resp = newNlohmannJsonResponse(
+        cavoke::server::model::GameSessionAccessObject::UserInfo::from_user(
+            user));
+    return callback(resp);
+}
+void UsersController::change_name(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    auto user_id = AuthFilter::get_user_id(req);
+
+    auto new_name = req->getOptionalParameter<std::string>("new_name");
+    if (!new_name.has_value()) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+
+    mp_users.updateBy(
+        {drogon_model::cavoke_orm::Users::Cols::_display_name},
+        drogon::orm::Criteria(drogon_model::cavoke_orm::Users::Cols::_id,
+                              drogon::orm::CompareOperator::EQ, user_id),
+        new_name.value());
+    auto user = mp_users.findByPrimaryKey(user_id);
+    auto resp = newNlohmannJsonResponse(
+        cavoke::server::model::GameSessionAccessObject::UserInfo::from_user(
+            user));
+    return callback(resp);
+}
+void UsersController::get_user(
+    const drogon::HttpRequestPtr &req,
+    std::function<void(const drogon::HttpResponsePtr &)> &&callback) {
+    auto req_user_id = req->getOptionalParameter<std::string>("req_user_id");
+    if (!req_user_id.has_value()) {
+        return CALLBACK_STATUS_CODE(k400BadRequest);
+    }
+
+    try {
+        auto user = mp_users.findByPrimaryKey(req_user_id.value());
+        auto resp = newNlohmannJsonResponse(
+            cavoke::server::model::GameSessionAccessObject::UserInfo::from_user(
+                user));
+        return callback(resp);
+    } catch (const drogon::orm::UnexpectedRows &) {
+        return CALLBACK_STATUS_CODE(k404NotFound);
+    }
+}
+}  // namespace cavoke::server::controllers
\ No newline at end of file
diff --git a/server/controllers/users_controller.h b/server/controllers/users_controller.h
new file mode 100644
index 00000000..f5d77f32
--- /dev/null
+++ b/server/controllers/users_controller.h
@@ -0,0 +1,44 @@
+#ifndef CAVOKE_USERS_CONTROLLER_H
+#define CAVOKE_USERS_CONTROLLER_H
+#include <drogon/HttpController.h>
+#include "sql-models/Users.h"
+#include "utils.h"
+
+namespace cavoke::server::controllers {
+
+struct UsersController : public drogon::HttpController<UsersController, true> {
+public:
+    METHOD_LIST_BEGIN
+    ADD_METHOD_TO(UsersController::get_me,
+                  "/profile/get_me",
+                  drogon::Get,
+                  "AuthFilter");
+    ADD_METHOD_TO(UsersController::change_name,
+                  "/profile/change_name",
+                  drogon::Post,
+                  "AuthFilter");
+    ADD_METHOD_TO(UsersController::get_user,
+                  "/users/get_user",
+                  drogon::Get,
+                  "AuthFilter");
+    METHOD_LIST_END
+
+protected:
+    void get_me(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void change_name(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+    void get_user(
+        const drogon::HttpRequestPtr &req,
+        std::function<void(const drogon::HttpResponsePtr &)> &&callback);
+
+private:
+    MAPPER_TYPE(drogon_model::cavoke_orm::Users)
+    mp_users = MAPPER_FOR(drogon_model::cavoke_orm::Users);
+};
+
+}  // namespace cavoke::server::controllers
+
+#endif  // CAVOKE_USERS_CONTROLLER_H
diff --git a/server/db/schema.sql b/server/db/schema.sql
new file mode 100644
index 00000000..bb46ee92
--- /dev/null
+++ b/server/db/schema.sql
@@ -0,0 +1,344 @@
+create table users
+(
+    id           varchar not null
+        constraint user_pk
+            primary key,
+    display_name varchar default 'Guest':: character varying
+);
+
+
+create table sessions
+(
+    id            uuid    not null
+        constraint session_pk
+            primary key,
+    game_id       varchar not null,
+    host_id       varchar null,
+    game_settings json,
+    constraint fk_host foreign key (host_id) references users (id)
+);
+
+create table rooms
+(
+    id           uuid    not null
+        constraint room_pk
+            primary key,
+    display_name varchar not null,
+    invite_code  varchar not null,
+    host_id      varchar null,
+    constraint fk_host foreign key (host_id) references users (id)
+);
+
+create table room_joins
+(
+
+    room_id uuid    not null
+        constraint joins_room_id_fk
+            references rooms
+            on delete cascade,
+    user_id varchar not null
+        constraint joins_user_id_fk
+            references users
+            on delete restrict,
+    constraint room_join_pk
+        primary key (room_id, user_id)
+);
+
+
+alter table rooms
+    add constraint rooms_joins_room_id_user_id_fk
+        foreign key (id, host_id) references room_joins (room_id, user_id);
+
+
+alter table rooms
+    add column session_id uuid null;
+alter table rooms
+    add constraint fk_session foreign key (session_id) references sessions (id);
+
+
+create table statuses
+(
+    session_id uuid not null
+        constraint status_session_id_fk
+            references sessions
+            on delete cascade,
+    status     integer,
+    saved_on   timestamp default current_timestamp
+);
+
+create unique index session_id_uindex
+    on sessions (id);
+
+create unique index room_invite_code_uindex
+    on rooms (invite_code);
+
+create table players
+(
+    session_id  uuid    not null
+        constraint player_session_id_fk
+            references sessions
+            on delete cascade,
+    user_id     varchar not null
+        constraint player_user_id_fk
+            references users
+            on delete restrict,
+    player_id   integer not null,
+    score       integer,
+    playerstate text    not null,
+    constraint player_pk
+        primary key (session_id, user_id),
+    constraint uq_playerid_sessionid
+        unique (session_id, player_id)
+);
+
+
+create table globalstates
+(
+    session_id  uuid                    not null
+        constraint globalstates_pk
+            primary key
+        constraint globalstates_sessions_id_fk
+            references sessions
+            on delete cascade,
+    globalstate text,
+    is_terminal boolean   default false not null,
+    saved_on    timestamp default current_timestamp
+);
+
+create table gamesubmissions
+(
+    id            uuid      default gen_random_uuid() not null
+        constraint gamesubmissions_pk
+            primary key,
+    game_id       varchar,
+    package_type  varchar,
+    git_repo      varchar,
+    review_status integer   default 0,
+    submitted_at  timestamp default CURRENT_TIMESTAMP,
+    display_name  varchar
+);
+
+create unique index gamesubmissions_id_uindex
+    on gamesubmissions (id);
+
+create or replace function leave_session(m_session_id uuid, m_user_id varchar) returns void as
+$$
+declare
+begin
+    if
+            (select host_id
+             from sessions
+             where id = m_session_id) = m_user_id then
+        if (select user_id
+            from players
+            where session_id = m_session_id
+              and user_id != m_user_id
+            limit 1) IS NOT NULL then
+            update sessions
+            set host_id = (select user_id from players where session_id = m_session_id and user_id != m_user_id limit 1)
+            where id = m_session_id;
+        else
+            update rooms
+            set session_id = NULL
+            where rooms.session_id = m_session_id;
+            delete
+            from sessions
+            where id = m_session_id;
+        end if;
+    end if;
+    delete
+    from players
+    where user_id = m_user_id
+      and session_id = m_session_id;
+end
+$$
+    language plpgsql;
+
+create or replace function leave_room(m_room_id uuid, m_user_id varchar) returns void as
+$$
+declare
+begin
+    if
+            (select host_id
+             from rooms
+             where id = m_room_id) = m_user_id then
+        if (select user_id
+            from room_joins
+            where room_id = m_room_id
+              and user_id != m_user_id
+            limit 1) IS NOT NULL then
+            update rooms
+            set host_id = (select user_id from room_joins where room_id = m_room_id and user_id != m_user_id limit 1)
+            where id = m_room_id;
+        else
+            delete
+            from rooms
+            where id = m_room_id;
+        end if;
+    end if;
+    delete
+    from room_joins
+    where user_id = m_user_id
+      and room_id = m_room_id;
+end
+$$
+    language plpgsql;
+
+-- STAISTICS
+
+create or replace function get_sessions_info(game_id_ varchar)
+    returns table
+            (
+                session_id uuid,
+                duration   numeric,
+                max_status integer
+            )
+as
+$$
+declare
+begin
+    -- noinspection SqlAggregates
+
+    RETURN QUERY SELECT statuses.session_id,
+                        EXTRACT(epoch from (MAX(statuses.saved_on) - MIN(statuses.saved_on))) as duration,
+                        MAX(statuses.status)                                                  as max_status
+                 FROM (statuses inner join sessions s on s.id = statuses.session_id)
+                 WHERE s.game_id = game_id_
+                   and (statuses.status = 1 or statuses.status = 2)
+                 GROUP BY statuses.session_id
+                 HAVING MAX(statuses.status) >= 2;
+end;
+$$
+    language plpgsql;
+
+create or replace function get_average_session_time_sec(game_id_ varchar) returns int as
+$$
+declare
+begin
+    RETURN (SELECT AVG(durations.duration)
+            FROM get_sessions_info(game_id_) as durations);
+end;
+$$
+    language plpgsql;
+
+create or replace function get_total_time_sec(game_id_ varchar) returns int as
+$$
+declare
+begin
+    RETURN (SELECT COALESCE(SUM(durations.duration), 0)
+            FROM get_sessions_info(game_id_) as durations);
+end;
+$$
+    language plpgsql;
+
+create or replace function get_sessions_num(game_id_ varchar) returns int as
+$$
+declare
+begin
+    RETURN (SELECT COUNT(durations.duration)
+            FROM get_sessions_info(game_id_) as durations);
+end;
+$$
+    language plpgsql;
+
+create or replace function get_average_players_num(game_id_ varchar) returns int as
+$$
+declare
+begin
+    RETURN (SELECT AVG(players_nums.players_num)
+            FROM (SELECT COUNT(*) AS players_num
+                  FROM (players inner join sessions s on s.id = players.session_id)
+                  WHERE game_id = game_id_
+                  GROUP BY session_id) as players_nums);
+end;
+$$
+    language plpgsql;
+
+
+create or replace function get_participations(game_id_ varchar, user_id_ varchar)
+    returns table
+            (
+                session_id uuid,
+                player_id  integer,
+                score      integer
+            )
+as
+$$
+declare
+begin
+    RETURN QUERY SELECT players.session_id, players.player_id, players.score
+                 FROM (players inner join sessions s on s.id = players.session_id)
+                 WHERE players.user_id = user_id_
+                   AND s.game_id = game_id_;
+end;
+$$
+    language plpgsql;
+
+create or replace function get_total_time_sec_for_user(game_id_ varchar, user_id_ varchar) returns int as
+$$
+declare
+begin
+    RETURN (SELECT COALESCE(SUM(user_sessions.duration), 0)
+            FROM (get_participations(game_id_, user_id_) p left join get_sessions_info(game_id_) s
+                  on p.session_id = s.session_id) as user_sessions);
+end;
+$$
+    language plpgsql;
+
+create or replace function get_sessions_num_for_user(game_id_ varchar, user_id_ varchar) returns int as
+$$
+declare
+begin
+    RETURN (SELECT (COUNT(*) FILTER ( WHERE user_sessions.score is not null))
+            FROM (get_participations(game_id_, user_id_) p left join get_sessions_info(game_id_) s
+                  on p.session_id = s.session_id) as user_sessions);
+end;
+$$
+    language plpgsql;
+
+create or replace function get_win_rate(game_id_ varchar, user_id_ varchar) returns float as
+$$
+declare
+begin
+    RETURN (SELECT CAST((COUNT(*) FILTER ( WHERE p.score > 0)) AS FLOAT) /
+                   NULLIF((COUNT(*) FILTER ( WHERE p.score is not null)), 0)
+            FROM get_participations(game_id_, user_id_) as p);
+end;
+$$
+    language plpgsql;
+
+create or replace function all_games()
+    returns table
+            (
+                game_id varchar
+            )
+as
+$$
+declare
+begin
+    RETURN QUERY (SELECT DISTINCT sessions.game_id FROM sessions);
+end;
+$$
+    language plpgsql;
+
+
+create or replace function get_cavoke_time_sec_for_user(user_id_ varchar) returns int as
+$$
+declare
+begin
+    RETURN (SELECT COALESCE(SUM(get_total_time_sec_for_user(g.game_id, user_id_)), 0)
+            FROM all_games() as g);
+end;
+$$
+    language plpgsql;
+
+
+create or replace function get_cavoke_sessions_num_for_user(user_id_ varchar) returns int as
+$$
+declare
+begin
+    RETURN (SELECT SUM(get_sessions_num_for_user(g.game_id, user_id_))
+            FROM all_games() as g);
+end;
+$$
+    language plpgsql;
diff --git a/server/example_config.json b/server/example_config.json
new file mode 100644
index 00000000..34fa9621
--- /dev/null
+++ b/server/example_config.json
@@ -0,0 +1,161 @@
+/* This is a JSON format configuration file
+ */
+{
+  //custom_config: custom configuration for users. This object can be acquired by the app().getCustomConfig() method.
+  "custom_config": {
+    "storage": {
+      "games_directory": "local_server/games",
+      "logic_name": "logic",
+      "zip_name": "client.zip",
+      "config_name": "config.json"
+    },
+    "cors": "*" // OPTIONAL cors header value
+//     // OPTIONAL Authentication settings. If commented out, `user_id` query will be used
+//        ,"auth": {
+//          "type": "JWT",
+//          "algorithm": "RS256",
+//          "audience": "https://develop.api.cavoke.wlko.me",
+//          "issuer": "https://cavoke.eu.auth0.com/",
+//          "public_key": "-----BEGIN CERTIFICATE-----\nMIIDATCCAemgAwIBAgIJUThDAEJOSIyCMA0GCSqGSIb3DQEBCwUAMB4xHDAaBgNV\nBAMTE2Nhdm9rZS5ldS5hdXRoMC5jb20wHhcNMjIwNDIzMTg0ODI2WhcNMzUxMjMx\nMTg0ODI2WjAeMRwwGgYDVQQDExNjYXZva2UuZXUuYXV0aDAuY29tMIIBIjANBgkq\nhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA7FmeNLDehyQNzYlPLvaM4XuTCcWe48dC\n6bjwWeuboPscJoA8V7RYpNbs8zkR4mNaXEN1exJahFttU8t50kRSa302BplBRnsD\nwFotpCEptRkVNdPac+0/7qKboqwDyi9gl5uT/Hm2kR090tqJgfKKBazx1QS3j3iO\nChPcA1FE2/vhmOhcSV9zbwQXUiXFUShPjDhfmcqTxABbxs7LgSgcM8qz0IhquxJq\nlrwWv5cTuD45iXPj8oSONyvsP1pz2H7qvKJhYtobAnDt+P6SS1rO4nma2RV/tt3A\ngCZ9jcybz+9Hrp3Xs+Ip7Hn+vYb/CxK6UHaMzO1iGUWWVJNQcVOVzQIDAQABo0Iw\nQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQlyPck1My8puTlg4tErVnUW+CE\nijAOBgNVHQ8BAf8EBAMCAoQwDQYJKoZIhvcNAQELBQADggEBAOOgBVDImV0D8ln8\n2mzAMDwO9plAx7mF9Qrfvr9/GW1BLisiBXJ56myMeXIvqatmf5hN/sWM/GjBdSoB\no5pdX5Wtbjik7GI1QCQB28ZHz2Y924NLAiZEllOW8jcCAfCt0fuqmz7fsJpjJBNY\nKp0ad8YsxnHjiclLTkjeShj/nN98O41pYx+thXuC9CSUtxxeAnzNyAgw5Tc67z7w\n5X5dubeRgsaTmFE665H+EzYAqAFyfUHXvNEkogqBPXRiBQUFuChFVFx6TTEfADV+\nKMTS0PaUX72LJpnLqsxUxquiJLqq515rBSc+9EH75xmKkD52DIeqfBHr1JPA5yP8\nXLXdlos=\n-----END CERTIFICATE-----"
+//        }
+  },
+  "db_clients": [
+    {
+      //name: Name of the client,'default' by default
+      "name": "default",
+      //rdbms: Server type, postgresql,mysql or sqlite3, "postgresql" by default
+      "rdbms": "postgresql",
+      //filename: Sqlite3 db file name
+      //"filename":"",
+      //host: Server address,localhost by default
+      "host": "127.0.0.1",
+      //port: Server port, 5432 by default
+      "port": 5432,
+      //dbname: Database name
+      "dbname": "<YOUR-DB-NAME-HERE>",
+      //user: 'postgres' by default
+      "user": "postgres",
+      //passwd: '' by default
+      "passwd": "<YOUR-DB-PASSWORD>",
+      //is_fast: false by default, if it is true, the client is faster but user can't call
+      //any synchronous interface of it.
+      "is_fast": false,
+      //client_encoding: The character set used by the client. it is empty string by default which
+      //means use the default character set.
+      //"client_encoding": "",
+      //number_of_connections: 1 by default, if the 'is_fast' is true, the number is the number of
+      //connections per IO thread, otherwise it is the total number of all connections.
+      "number_of_connections": 1,
+      //timeout: -1.0 by default, in seconds, the timeout for executing a SQL query.
+      //zero or negative value means no timeout.
+      "timeout": -1.0
+    }
+  ],
+  "app": {
+    //number_of_threads: The number of IO threads, 1 by default, if the value is set to 0, the number of threads
+    //is the number of CPU cores
+    "number_of_threads": 1,
+    "upload_path": "uploads",
+    //enable_session: False by default
+    "enable_session": false,
+    "session_timeout": 0,
+    //max_connections: maximum number of connections, 100000 by default
+    "max_connections": 100000,
+    //max_connections_per_ip: maximum number of connections per client, 0 by default which means no limit
+    "max_connections_per_ip": 0,
+    //Load_dynamic_views: False by default, when set to true, drogon
+    //compiles and loads dynamically "CSP View Files" in directories defined
+    //by "dynamic_views_path"
+    "load_dynamic_views": false,
+    //dynamic_views_path: If the path isn't prefixed with /, ./ or ../,
+    //it is relative path of document_root path
+    "dynamic_views_path": [
+      "./views"
+    ],
+    //dynamic_views_output_path: Default by an empty string which means the output path of source
+    //files is the path where the csp files locate. If the path isn't prefixed with /, it is relative
+    //path of the current working directory.
+    "dynamic_views_output_path": "",
+    //enable_unicode_escaping_in_json: true by default, enable unicode escaping in json.
+    "enable_unicode_escaping_in_json": true,
+    //float_precision_in_json: set precision of float number in json.
+    "float_precision_in_json": {
+      //precision: 0 by default, 0 means use the default precision of the jsoncpp lib.
+      "precision": 0,
+      //precision_type: must be "significant" or "decimal", defaults to "significant" that means
+      //setting max number of significant digits in string, "decimal" means setting max number of
+      //digits after "." in string
+      "precision_type": "significant"
+    },
+    //log: Set log output, drogon output logs to stdout by default
+    "log": {
+      //log_path: Log file path,empty by default,in which case,logs are output to the stdout
+      "log_path": "./",
+      //logfile_base_name: Log file base name,empty by default which means drogon names logfile as
+      //drogon.log ...
+      "logfile_base_name": "cavoke-server",
+      //log_size_limit: 100000000 bytes by default,
+      //When the log file size reaches "log_size_limit", the log file is switched.
+      "log_size_limit": 100000000,
+      //log_level: "DEBUG" by default,options:"TRACE","DEBUG","INFO","WARN"
+      //The TRACE level is only valid when built in DEBUG mode.
+      "log_level": "DEBUG"
+    },
+    //run_as_daemon: False by default
+    "run_as_daemon": false,
+    //handle_sig_term: True by default
+    "handle_sig_term": true,
+    //relaunch_on_error: False by default, if true, the program will be restarted by the parent after exiting;
+    "relaunch_on_error": false,
+    //use_sendfile: True by default, if true, the program
+    //uses sendfile() system-call to send static files to clients;
+    "use_sendfile": true,
+    //use_gzip: True by default, use gzip to compress the response body's content;
+    "use_gzip": true,
+    //use_brotli: False by default, use brotli to compress the response body's content;
+    "use_brotli": false,
+    //static_files_cache_time: 5 (seconds) by default, the time in which the static file response is cached,
+    //0 means cache forever, the negative value means no cache
+    "static_files_cache_time": 5,
+    //idle_connection_timeout: Defaults to 60 seconds, the lifetime
+    //of the connection without read or write
+    "idle_connection_timeout": 60,
+    //server_header_field: Set the 'Server' header field in each response sent by drogon,
+    //empty string by default with which the 'Server' header field is set to "Server: drogon/version string\r\n"
+    "server_header_field": "",
+    //enable_server_header: Set true to force drogon to add a 'Server' header to each HTTP response. The default
+    //value is true.
+    "enable_server_header": true,
+    //enable_date_header: Set true to force drogon to add a 'Date' header to each HTTP response. The default
+    //value is true.
+    "enable_date_header": true,
+    //keepalive_requests: Set the maximum number of requests that can be served through one keep-alive connection.
+    //After the maximum number of requests are made, the connection is closed.
+    //The default value of 0 means no limit.
+    "keepalive_requests": 0,
+    //pipelining_requests: Set the maximum number of unhandled requests that can be cached in pipelining buffer.
+    //After the maximum number of requests are made, the connection is closed.
+    //The default value of 0 means no limit.
+    "pipelining_requests": 0,
+    //gzip_static: If it is set to true, when the client requests a static file, drogon first finds the compressed
+    //file with the extension ".gz" in the same path and send the compressed file to the client.
+    //The default value of gzip_static is true.
+    "gzip_static": true,
+    //br_static: If it is set to true, when the client requests a static file, drogon first finds the compressed
+    //file with the extension ".br" in the same path and send the compressed file to the client.
+    //The default value of br_static is true.
+    "br_static": true,
+    //client_max_body_size: Set the maximum body size of HTTP requests received by drogon. The default value is "1M".
+    //One can set it to "1024", "1k", "10M", "1G", etc. Setting it to "" means no limit.
+    "client_max_body_size": "128M",
+    //max_memory_body_size: Set the maximum body size in memory of HTTP requests received by drogon. The default value is "64K" bytes.
+    //If the body size of an HTTP request exceeds this limit, the body is stored to a temporary file for processing.
+    //Setting it to "" means no limit.
+    "client_max_memory_body_size": "64K",
+    //client_max_websocket_message_size: Set the maximum size of messages sent by WebSocket client. The default value is "128K".
+    //One can set it to "1024", "1k", "10M", "1G", etc. Setting it to "" means no limit.
+    "client_max_websocket_message_size": "128K",
+    //reuse_port: Defaults to false, users can run multiple processes listening on the same port at the same time.
+    "reuse_port": false
+  }
+}
diff --git a/server/filters/AuthFilter.cc b/server/filters/AuthFilter.cc
new file mode 100644
index 00000000..8a69193a
--- /dev/null
+++ b/server/filters/AuthFilter.cc
@@ -0,0 +1,89 @@
+#include "AuthFilter.h"
+#include <stdexcept>
+
+using namespace drogon;
+AuthFilter::AuthFilter() {
+    // get config
+    auto app_config = nlohmann::to_nlohmann(drogon::app().getCustomConfig());
+    // check if auth config is present
+    if (app_config.contains(SETTINGS_KEYNAME)) {
+        // if yes, parse it
+        auto config = app_config.at("auth").get<AuthConfig>();
+        // check supported token type and algorithm
+        assert(config.type == "JWT");
+        assert(config.algorithm == "RS256");
+        // initialize JWT token verifier with public key
+        verifier =
+            nlohmann_verifier{jwt::default_clock()}
+                .with_audience(config.audience)
+                .with_issuer(config.issuer)
+                .allow_algorithm(jwt::algorithm::rs256(config.public_key));
+        LOG_INFO << config.type << " auth guard enabled (iss=" << config.issuer
+                 << ", aud=" << config.audience << ")";
+    } else {
+        // If no auth config is found, warn the server admin
+        // Any users will be allowed access to guarded methods by
+        // a `user_id` query param
+        LOG_WARN << "No auth guard used...";
+        verifier = {};
+    }
+}
+
+void AuthFilter::doFilter(const HttpRequestPtr &req,
+                          FilterCallback &&fcb,
+                          FilterChainCallback &&fccb) {
+    try {
+        // if no authentication configured, just get user id parameter
+        if (!verifier.has_value()) {
+            auto user_id = req->getOptionalParameter<std::string>(USER_ID_NAME);
+            if (!user_id.has_value()) {
+                throw std::runtime_error("no user_id query parameter");
+            }
+            req->addCookie(USER_ID_NAME, user_id.value());
+            // add user to db
+            register_user(user_id.value());
+            return fccb();
+        }
+        // get authorization header
+        std::string token =
+            extract_token_from_header(req->getHeader(AUTHORIZATION_HEADER));
+        // decode and verify Bearer token
+        auto decoded = jwt::decode<jwt::traits::nlohmann_json>(token);
+        verifier->verify(decoded);
+        // Pass user id to methods
+        auto subject = decoded.get_subject();
+        req->addCookie(USER_ID_NAME, subject);
+        // add user to db
+        register_user(subject);
+        return fccb();
+    } catch (const std::exception &err) {
+        LOG_WARN << "Auth check failed: " << err.what();
+        // Authentication failed
+        return fcb(cavoke::server::controllers::newStatusCodeResponse(
+            k401Unauthorized));
+    }
+}
+
+std::string AuthFilter::extract_token_from_header(
+    const std::string &auth_header) {
+    if (auth_header.size() < TOKEN_PREFIX.size()) {
+        throw std::invalid_argument("Invalid Bearer token");
+    }
+    return {auth_header.begin() + TOKEN_PREFIX.size(), auth_header.end()};
+}
+
+void AuthFilter::register_user(const std::string &user_id) const {
+    drogon_model::cavoke_orm::Users user;
+    // add user to db if not present
+    drogon::app().getDbClient()->execSqlSync(
+        "insert into users (id) values ($1) on conflict do nothing", user_id);
+}
+
+std::string AuthFilter::get_user_id(const HttpRequestPtr &req) {
+    return req->getCookie(USER_ID_NAME);
+}
+
+const std::string AuthFilter::AUTHORIZATION_HEADER = "Authorization";
+const std::string AuthFilter::TOKEN_PREFIX = "Bearer ";
+const std::string AuthFilter::SETTINGS_KEYNAME = "auth";
+const std::string AuthFilter::USER_ID_NAME = "user_id";
diff --git a/server/filters/AuthFilter.h b/server/filters/AuthFilter.h
new file mode 100644
index 00000000..bb92e4c3
--- /dev/null
+++ b/server/filters/AuthFilter.h
@@ -0,0 +1,62 @@
+#pragma once
+
+#include <drogon/HttpAppFramework.h>
+#include <drogon/HttpFilter.h>
+#include <jwt-cpp/jwt.h>
+#include <jwt-cpp/traits/nlohmann-json/traits.h>
+#include "sql-models/Users.h"
+#include "utils.h"
+
+using namespace drogon;
+using nlohmann_verifier =
+    jwt::verifier<jwt::default_clock, jwt::traits::nlohmann_json>;
+/** Provides an authentication interceptor that checks a bearer token
+ *  using a public key given in the configuration file.
+ *
+ *  If authenticated, makes user_id available to controllers through
+ * `AuthFilter::get_user_id(req)`.
+ *
+ *  If no configuration for `auth` is found, allows all requests and acquires
+ * `user_id` from query param with the same name. A corresponding warning about
+ * running in the insecure mode will be displayed in the logs.
+ */
+class AuthFilter : public HttpFilter<AuthFilter> {
+public:
+    AuthFilter();
+    void doFilter(const HttpRequestPtr &req,
+                  FilterCallback &&fcb,
+                  FilterChainCallback &&fccb) override;
+
+    struct AuthConfig {
+        std::string type;
+        std::string algorithm;
+        std::string audience;
+        std::string issuer;
+        std::string public_key;
+    };
+    /// Acquires `user_id` parsed during `AuthFilter`'s execution
+    static std::string get_user_id(const HttpRequestPtr &);
+
+private:
+    std::optional<nlohmann_verifier> verifier;
+
+    static std::string extract_token_from_header(
+        const std::string &auth_header);
+
+    mutable MAPPER_TYPE(drogon_model::cavoke_orm::Users) mp_users =
+        MAPPER_FOR(drogon_model::cavoke_orm::Users);
+
+    void register_user(const std::string &) const;
+
+    static const std::string AUTHORIZATION_HEADER;
+    static const std::string TOKEN_PREFIX;
+    static const std::string SETTINGS_KEYNAME;
+    static const std::string USER_ID_NAME;
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(AuthFilter::AuthConfig,
+                                   type,
+                                   algorithm,
+                                   audience,
+                                   issuer,
+                                   public_key)
\ No newline at end of file
diff --git a/server/main.cpp b/server/main.cpp
index eceadc6f..d2a45349 100644
--- a/server/main.cpp
+++ b/server/main.cpp
@@ -1,28 +1,35 @@
 #include <drogon/HttpAppFramework.h>
+#include <boost/algorithm/string/join.hpp>
 #include <boost/program_options.hpp>
+#include <boost/range/adaptor/transformed.hpp>
 #include "controllers/games_controller.h"
+#include "controllers/rooms_controller.h"
 #include "controllers/sessions_controller.h"
 #include "controllers/state_controller.h"
-#include "model/game_logic_manager.h"
-#include "model/games_storage.h"
+#include "controllers/statistics_controller.h"
+#include "model/games/games_storage.h"
+#include "model/logic/game_logic_manager.h"
+#include "model/rooms/rooms_storage.h"
 #include "model/sessions/sessions_storage.h"
+#include "model/statistics/statistics_manager.h"
 
 namespace cavoke::server {
-void run(const std::string &host,
-         uint16_t port,
-         const std::string &config_file) {
+void run(const model::GamesStorageConfig &games_storage_config) {
     // TODO: logging
 
     // init models
     std::cout << "Initialize models..." << std::endl;
-    auto games_storage = std::make_shared<model::GamesStorage>(
-        model::GamesStorageConfig::load(config_file));
+    auto games_storage =
+        std::make_shared<model::GamesStorage>(games_storage_config);
     auto game_logic_manager =
         std::make_shared<model::GameLogicManager>(games_storage);
     auto game_state_storage = std::make_shared<model::GameStateStorage>();
-    auto participation_storage = std::make_shared<model::SessionsStorage>();
-    auto authentication_manager =
-        std::make_shared<model::AuthenticationManager>();
+    auto sessions_storage = std::make_shared<model::SessionsStorage>(
+        game_logic_manager, games_storage, game_state_storage);
+    auto statistics_manager = std::make_shared<model::StatisticsManager>(
+        sessions_storage, games_storage);
+    auto rooms_storage =
+        std::make_shared<model::RoomsStorage>(sessions_storage);
 
     // init controllers
     std::cout << "Initialize controllers..." << std::endl;
@@ -30,11 +37,16 @@ void run(const std::string &host,
         std::make_shared<controllers::GamesController>(games_storage);
     auto state_controller = std::make_shared<controllers::StateController>(
         games_storage, game_logic_manager, game_state_storage,
-        participation_storage);
+        sessions_storage);
     auto sessions_controller =
         std::make_shared<controllers::SessionsController>(
             games_storage, game_logic_manager, game_state_storage,
-            participation_storage, authentication_manager);
+            sessions_storage);
+    auto statistics_controller =
+        std::make_shared<controllers::StatisticsController>(games_storage,
+                                                            statistics_manager);
+    auto rooms_controller = std::make_shared<controllers::RoomsController>(
+        rooms_storage, games_storage, sessions_storage);
 
     auto &app = drogon::app();
 
@@ -42,10 +54,44 @@ void run(const std::string &host,
     app.registerController(games_controller);
     app.registerController(state_controller);
     app.registerController(sessions_controller);
+    app.registerController(statistics_controller);
+    app.registerController(rooms_controller);
+
+    // print db and listeners on start
+    app.registerBeginningAdvice([]() {
+        auto dbclient = drogon::app().getDbClient();
+        dbclient->connectionInfo();
+        std::cout << "Database connection: "
+                  << (dbclient == nullptr
+                          ? "FAILED"
+                          : hide_password(dbclient->connectionInfo()))
+                  << std::endl;
+
+        auto listeners = drogon::app().getListeners();
+        std::string ips =
+            listeners.empty()
+                ? "<NO LISTENERS>"
+                : boost::join(
+                      listeners | boost::adaptors::transformed(
+                                      [](const trantor::InetAddress &e) {
+                                          return e.toIpPort();
+                                      }),
+                      ", ");
+        std::cout << "Listening at " << ips << "... " << std::endl;
+    });
+
+    // Add CORS handler
+    auto corsValue = nlohmann::to_nlohmann(drogon::app().getCustomConfig())
+                         .value("cors", "*");
+    app.registerPostHandlingAdvice(
+        [corsValue](const drogon::HttpRequestPtr &req,
+                    const drogon::HttpResponsePtr &resp) {
+            // cors header for every response
+            resp->addHeader("Access-Control-Allow-Origin", corsValue);
+        });
 
     // start server
-    std::cout << "Listening at " << host << ":" << port << std::endl;
-    app.addListener(host, port).run();
+    app.run();
 }
 }  // namespace cavoke::server
 
@@ -53,13 +99,12 @@ namespace po = boost::program_options;
 
 int main(int argc, char *argv[]) {
     po::options_description desc("Allowed options");
-    desc.add_options()("help,h", "Print help")(
-        "config-file,c", po::value<std::string>(),
-        "File with game storage configuration")(
-        "host,ip,a", po::value<std::string>()->default_value("0.0.0.0"),
-        "Host on which server is located")(
-        "port,p", po::value<uint16_t>()->default_value(8080),
-        "TCP/IP port number for connection");
+    auto add_desc_options = desc.add_options();
+    add_desc_options("help,h", "Print help");
+    add_desc_options("config-file,c", po::value<std::string>(),
+                     "File with game storage configuration");
+    add_desc_options("port,p", po::value<uint16_t>()->default_value(8080),
+                     "TCP/IP port number for connection");
 
     po::variables_map vm;
     po::store(po::parse_command_line(argc, argv, desc), vm);
@@ -70,17 +115,39 @@ int main(int argc, char *argv[]) {
         return 0;
     }
 
-    std::string config_file;
+    cavoke::server::model::GamesStorageConfig games_storage_config;
     if (vm.count("config-file")) {
-        config_file = vm["config-file"].as<std::string>();
+        // load from file
+        try {
+            std::string file = vm["config-file"].as<std::string>();
+            drogon::app().loadConfigFile(file);
+            games_storage_config =
+                nlohmann::to_nlohmann(drogon::app().getCustomConfig())
+                    .at("storage")
+                    .get<cavoke::server::model::GamesStorageConfig>();
+            std::cout << "Server configuration loaded from: '" << file << "'\n";
+        } catch (const std::exception &err) {
+            std::cerr
+                << "Failed to load games storage configuration from file: "
+                << err.what() << '\n';
+            return 1;
+        }
     } else {
-        //    config_file = std::getenv("CAVOKE_SERVER_CONFIG"); // TODO: think
-        //    and discuss
+        // use default one
+        std::cerr
+            << "No server configuration file specified. Using a default "
+               "one.\nWARNING: No database requests will succeed.\nPlease use "
+               "`-c` option to specify config file.\n";
+        // default configuration
+        games_storage_config = {"../../local_server/games", "logic",
+                                "client.zip", "config.json"};
     }
 
-    std::string host = vm.at("host").as<std::string>();
-    uint16_t port = vm.at("port").as<uint16_t>();
+    if (vm.count("port")) {
+        uint16_t port = vm.at("port").as<uint16_t>();
+        drogon::app().addListener("0.0.0.0", port);
+    }
 
-    cavoke::server::run(host, port, config_file);
+    cavoke::server::run(games_storage_config);
     return 0;
 }
diff --git a/server/model/auth/authentication_manager.cpp b/server/model/auth/authentication_manager.cpp
deleted file mode 100644
index ec0abd91..00000000
--- a/server/model/auth/authentication_manager.cpp
+++ /dev/null
@@ -1,6 +0,0 @@
-#include "authentication_manager.h"
-bool cavoke::server::model::AuthenticationManager::verify_authentication(
-    const std::string &user_id) const {
-    // TODO
-    return true;
-}
diff --git a/server/model/auth/authentication_manager.h b/server/model/auth/authentication_manager.h
deleted file mode 100644
index 253f53b8..00000000
--- a/server/model/auth/authentication_manager.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef CAVOKE_AUTHENTICATION_MANAGER_H
-#define CAVOKE_AUTHENTICATION_MANAGER_H
-
-#include <string>
-
-namespace cavoke::server::model {
-/// Manager for checking user's authentication.
-/// In future it will be JWT/JWK verification.
-class AuthenticationManager {
-public:
-    /// Checks whether user_id is valid. signature will change in the future.
-    [[nodiscard]] bool verify_authentication(const std::string &user_id) const;
-};
-}  // namespace cavoke::server::model
-
-#endif  // CAVOKE_AUTHENTICATION_MANAGER_H
diff --git a/server/model/game_logic_manager.cpp b/server/model/game_logic_manager.cpp
deleted file mode 100644
index 4f090606..00000000
--- a/server/model/game_logic_manager.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-#include "game_logic_manager.h"
-// workaround for a boost bug...
-// https://github.com/boostorg/process/issues/96
-#ifndef __kernel_entry
-#define __kernel_entry
-#endif
-#include <boost/process.hpp>
-#include <utility>
-
-namespace cavoke::server::model {
-
-GameLogicManager::GameLogicManager(std::shared_ptr<GamesStorage> games_storage)
-    : m_games_storage(std::move(games_storage)) {
-}
-
-std::string GameLogicManager::invoke_logic(const Game &game,
-                                           const std::string &input) {
-    namespace bp = boost::process;
-    bp::opstream in;
-    bp::ipstream out;
-
-    bp::child c(game.logic_file, bp::std_out > out, bp::std_in < in);
-    in.write(input.c_str(), static_cast<int>(input.size()));
-    in.flush();
-
-    in.pipe().close();
-
-    if (!c.wait_for(std::chrono::milliseconds{500})) {
-        c.terminate();
-    }
-
-    std::string output;
-    std::string line;
-
-    while (std::getline(out, line)) {
-        output += line;
-        output.push_back('\n');
-    }
-
-    return output;
-}
-
-bool GameLogicManager::validate_settings(
-    const std::string &game_id,
-    const json &settings,
-    const std::vector<int> &occupied_positions,
-    std::string &error_message) {
-    std::optional<Game> game_info = m_games_storage->get_game_by_id(game_id);
-    if (!game_info.has_value()) {
-        return {};
-    }
-
-    std::ostringstream request;
-    request << "VALIDATE ";
-    json request_data = InitSettings{settings, occupied_positions};
-    request << request_data;
-
-    json response_json =
-        json::parse(invoke_logic(game_info.value(), request.str()));
-    auto result = response_json.get<ValidationResult>();
-    error_message = std::move(result.message);
-
-    return result.success;
-}
-
-GameStateStorage::GameState GameLogicManager::init_state(
-    const std::string &game_id,
-    const json &settings,
-    const std::vector<int> &occupied_positions) {
-    std::optional<Game> game_info = m_games_storage->get_game_by_id(game_id);
-    if (!game_info.has_value()) {
-        return {};
-    }
-
-    std::ostringstream request;
-    request << "INIT ";
-    json request_data = InitSettings{settings, occupied_positions};
-    request << request_data;
-
-    json response_json =
-        json::parse(invoke_logic(game_info.value(), request.str()));
-    auto result = response_json.get<GameStateStorage::GameState>();
-
-    return result;
-}
-
-GameStateStorage::GameState GameLogicManager::send_move(
-    const std::string &game_id,
-    const GameLogicManager::GameMove &move) {
-    std::optional<Game> game_info = m_games_storage->get_game_by_id(game_id);
-    if (!game_info.has_value()) {
-        return {};
-    }
-
-    std::ostringstream request;
-    request << "MOVE ";
-    json request_data = move;
-    request << request_data;
-
-    json response_json =
-        json::parse(invoke_logic(game_info.value(), request.str()));
-    auto result = response_json.get<GameStateStorage::GameState>();
-
-    return result;
-}
-
-}  // namespace cavoke::server::model
diff --git a/server/model/game_logic_manager.h b/server/model/game_logic_manager.h
deleted file mode 100644
index 589c781e..00000000
--- a/server/model/game_logic_manager.h
+++ /dev/null
@@ -1,62 +0,0 @@
-#ifndef CAVOKE_SERVER_GAME_LOGIC_MANAGER_H
-#define CAVOKE_SERVER_GAME_LOGIC_MANAGER_H
-
-#include <memory>
-#include <string>
-#include "game_state_storage.h"
-#include "games_storage.h"
-
-namespace cavoke::server::model {
-
-class GameLogicManager {
-    std::shared_ptr<GamesStorage> m_games_storage;
-
-    std::string invoke_logic(const Game &game, const std::string &input);
-
-public:
-    explicit GameLogicManager(std::shared_ptr<GamesStorage> games_storage);
-
-    struct GameMove {
-        int player_id;
-        std::string move;
-        std::string global_state;
-    };
-
-    struct InitSettings {
-        json settings;
-        std::vector<int> occupied_positions;
-    };
-
-    struct ValidationResult {
-        bool success;
-        std::string message;
-    };
-
-    bool validate_settings(const std::string &game_id,
-                           const json &settings,
-                           const std::vector<int> &occupied_positions,
-                           std::string &error_message);
-
-    GameStateStorage::GameState init_state(
-        const std::string &game_id,
-        const json &settings,
-        const std::vector<int> &occupied_positions);
-
-    GameStateStorage::GameState send_move(const std::string &game_id,
-                                          const GameMove &move);
-};
-
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameLogicManager::InitSettings,
-                                   settings,
-                                   occupied_positions);
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameLogicManager::GameMove,
-                                   player_id,
-                                   move,
-                                   global_state);
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameLogicManager::ValidationResult,
-                                   success,
-                                   message);
-
-}  // namespace cavoke::server::model
-
-#endif  // CAVOKE_SERVER_GAME_LOGIC_MANAGER_H
diff --git a/server/model/game_state_storage.cpp b/server/model/game_state_storage.cpp
deleted file mode 100644
index bfa64c94..00000000
--- a/server/model/game_state_storage.cpp
+++ /dev/null
@@ -1,53 +0,0 @@
-#include "game_state_storage.h"
-#include <json/reader.h>
-#include <utility>
-
-namespace cavoke::server::model {
-
-void GameStateStorage::save_state(const std::string &session_id,
-                                  GameStateStorage::GameState new_state) {
-    m_states[session_id] = std::move(new_state);
-}
-
-std::optional<GameStateStorage::GameState> GameStateStorage::get_state(
-    const std::string &session_id) {
-    if (m_states.count(session_id) == 0) {
-        return {};
-    }
-    return m_states[session_id];
-}
-
-GameStateStorage::GameState GameStateStorage::parse_state(
-    const std::string &s) {
-    GameState state;
-    Json::Value json_state;
-    Json::Reader reader;
-    reader.parse(s, json_state, false);
-    state.is_terminal = json_state["is_terminal"].asBool();
-    state.global_state = json_state["global_state"].asString();
-    for (Json::Value::ArrayIndex i = 0; i != json_state["players_state"].size();
-         i++) {
-        state.players_state.push_back(
-            json_state["players_state"][i].asString());
-    }
-    for (Json::Value::ArrayIndex i = 0; i != json_state["winners"].size();
-         i++) {
-        state.winners.push_back(json_state["winners"][i].asInt());
-    }
-    return state;
-}
-
-std::optional<std::string> GameStateStorage::get_player_state(
-    const std::string &session_id,
-    int player_id) {
-    auto state = get_state(session_id);
-    if (!state.has_value()) {
-        return {};
-    }
-    if (player_id >= state->players_state.size()) {
-        return {};
-    }
-    return state->players_state[player_id];
-}
-
-}  // namespace cavoke::server::model
diff --git a/server/model/game.cpp b/server/model/games/game.cpp
similarity index 100%
rename from server/model/game.cpp
rename to server/model/games/game.cpp
diff --git a/server/model/game.h b/server/model/games/game.h
similarity index 87%
rename from server/model/game.h
rename to server/model/games/game.h
index ddf51ae0..7e564373 100644
--- a/server/model/game.h
+++ b/server/model/games/game.h
@@ -12,7 +12,10 @@ struct GameConfig {
     std::string id;
     std::string display_name;
     std::string description;
+    std::string app_type;
+    std::string url;
     int players_num;
+    std::vector<std::string> role_names;
     json default_settings;
 
     /// Validates config. Throws an exception if invalid
@@ -25,7 +28,10 @@ NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameConfig,
                                    id,
                                    display_name,
                                    description,
+                                   app_type,
+                                   url,
                                    players_num,
+                                   role_names,
                                    default_settings)
 
 class Game {
@@ -33,13 +39,12 @@ class Game {
     const std::string CLIENT_FILE;
     const std::string LOGIC_FILE;
 
-    boost::filesystem::path directory;
-
 public:
     explicit Game(const boost::filesystem::path &directory,
                   const GamesStorageConfig &game_storage_config);
     Game() = default;
 
+    boost::filesystem::path directory;
     boost::filesystem::path client_file;
     GameConfig config;
     boost::filesystem::path logic_file;
diff --git a/server/model/games_storage.cpp b/server/model/games/games_storage.cpp
similarity index 86%
rename from server/model/games_storage.cpp
rename to server/model/games/games_storage.cpp
index 8594f953..6afc4df6 100644
--- a/server/model/games_storage.cpp
+++ b/server/model/games/games_storage.cpp
@@ -31,14 +31,21 @@ std::vector<Game> GamesStorage::list_games() {
     update();
 
     std::vector<Game> result;
-    for (const auto &e : m_games) {
-        // cppcheck-suppress useStlAlgorithm
-        result.emplace_back(e.second);
+
+    {
+        std::shared_lock lock(m_games_mtx);
+        for (const auto &e : m_games) {
+            // cppcheck-suppress useStlAlgorithm
+            result.emplace_back(e.second);
+        }
     }
+
     return result;
 }
 
 void GamesStorage::update() {
+    std::unique_lock lock(m_games_mtx);
+
     m_games.clear();
     for (auto &entry : boost::make_iterator_range(
              boost::filesystem::directory_iterator(m_config.games_directory),
@@ -56,6 +63,8 @@ void GamesStorage::update() {
 }
 
 std::optional<Game> GamesStorage::get_game_by_id(const std::string &game_id) {
+    std::shared_lock lock(m_games_mtx);
+
     if (m_games.count(game_id) > 0) {
         return m_games[game_id];
     }
diff --git a/server/model/games_storage.h b/server/model/games/games_storage.h
similarity index 91%
rename from server/model/games_storage.h
rename to server/model/games/games_storage.h
index 354e9209..202fd8f6 100644
--- a/server/model/games_storage.h
+++ b/server/model/games/games_storage.h
@@ -3,13 +3,13 @@
 
 #include <drogon/drogon.h>
 #include <boost/filesystem/path.hpp>
+#include <shared_mutex>
 #include <string>
 #include "game.h"
 #include "games_storage_config.h"
 namespace cavoke::server::model {
 
 class GamesStorage {
-    // TODO: thread-safety
 public:
     explicit GamesStorage(GamesStorageConfig config);
 
@@ -22,6 +22,7 @@ class GamesStorage {
 private:
     GamesStorageConfig m_config;
     std::map<std::string, Game> m_games;
+    std::shared_mutex m_games_mtx;
 };
 
 }  // namespace cavoke::server::model
diff --git a/server/model/games_storage_config.cpp b/server/model/games/games_storage_config.cpp
similarity index 61%
rename from server/model/games_storage_config.cpp
rename to server/model/games/games_storage_config.cpp
index 46a48c11..0abfa839 100644
--- a/server/model/games_storage_config.cpp
+++ b/server/model/games/games_storage_config.cpp
@@ -1,26 +1,19 @@
-#include "games_storage_config.h"
-#include <boost/filesystem.hpp>
-#include <iostream>
-
-namespace cavoke::server::model {
-
-GamesStorageConfig GamesStorageConfig::load(const std::string &config_file) {
-    if (config_file.empty()) {
-        // FIXME: rewrite this mess...
-        std::cerr << "No games storage config specified. Using a default one. "
-                     "Please use `-c` option.\n";
-        return GamesStorageConfig{"../../local_server/games", "logic",
-                                  "client.zip", "config.json"};
-    }
-    if (!boost::filesystem::exists(config_file) ||
-        !boost::filesystem::is_regular_file(config_file)) {  // FIXME
-        throw std::invalid_argument(
-            "No such game storage configuration file: " + config_file);
-    }
-
-    std::ifstream file(config_file);
-    json j = json::parse(file);
-    return j.get<GamesStorageConfig>();
-}
-
+#include "games_storage_config.h"
+#include <boost/filesystem.hpp>
+#include <iostream>
+
+namespace cavoke::server::model {
+
+GamesStorageConfig GamesStorageConfig::load(const std::string &config_file) {
+    if (!boost::filesystem::exists(config_file) ||
+        !boost::filesystem::is_regular_file(config_file)) {  // FIXME
+        throw std::invalid_argument(
+            "No such game storage configuration file: " + config_file);
+    }
+
+    std::ifstream file(config_file);
+    json j = json::parse(file);
+    return j.get<GamesStorageConfig>();
+}
+
 }  // namespace cavoke::server::model
\ No newline at end of file
diff --git a/server/model/games_storage_config.h b/server/model/games/games_storage_config.h
similarity index 97%
rename from server/model/games_storage_config.h
rename to server/model/games/games_storage_config.h
index 2a2bc1fa..3364d793 100644
--- a/server/model/games_storage_config.h
+++ b/server/model/games/games_storage_config.h
@@ -1,24 +1,24 @@
-#ifndef CAVOKE_GAMES_STORAGE_CONFIG_H
-#define CAVOKE_GAMES_STORAGE_CONFIG_H
-
-#include <boost/filesystem/path.hpp>
-#include <nlohmann/json.hpp>
-#include "utils.h"
-namespace cavoke::server::model {
-using json = nlohmann::json;
-
-struct GamesStorageConfig {
-    boost::filesystem::path games_directory;
-    std::string logic_name;
-    std::string zip_name;
-    std::string config_name;
-
-    static GamesStorageConfig load(const std::string &config_file);
-};
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GamesStorageConfig,
-                                   games_directory,
-                                   logic_name,
-                                   zip_name,
-                                   config_name)
-}  // namespace cavoke::server::model
-#endif  // CAVOKE_GAMES_STORAGE_CONFIG_H
+#ifndef CAVOKE_GAMES_STORAGE_CONFIG_H
+#define CAVOKE_GAMES_STORAGE_CONFIG_H
+
+#include <boost/filesystem/path.hpp>
+#include <nlohmann/json.hpp>
+#include "utils.h"
+namespace cavoke::server::model {
+using json = nlohmann::json;
+
+struct GamesStorageConfig {
+    boost::filesystem::path games_directory;
+    std::string logic_name;
+    std::string zip_name;
+    std::string config_name;
+
+    static GamesStorageConfig load(const std::string &config_file);
+};
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GamesStorageConfig,
+                                   games_directory,
+                                   logic_name,
+                                   zip_name,
+                                   config_name)
+}  // namespace cavoke::server::model
+#endif  // CAVOKE_GAMES_STORAGE_CONFIG_H
diff --git a/server/model/logic/game_logic_manager.cpp b/server/model/logic/game_logic_manager.cpp
new file mode 100644
index 00000000..c6cd7ee1
--- /dev/null
+++ b/server/model/logic/game_logic_manager.cpp
@@ -0,0 +1,160 @@
+#include "game_logic_manager.h"
+// workaround for a boost bug...
+// https://github.com/boostorg/process/issues/96
+#ifndef __kernel_entry
+#define __kernel_entry
+#endif
+#include <boost/asio.hpp>
+#include <boost/process.hpp>
+#include <utility>
+
+namespace cavoke::server::model {
+
+GameLogicManager::GameLogicManager(std::shared_ptr<GamesStorage> games_storage)
+    : m_games_storage(std::move(games_storage)) {
+}
+
+std::string GameLogicManager::invoke_logic_local(const Game &game,
+                                                 const std::string &input) {
+    namespace bp = boost::process;
+    boost::asio::io_service ios;
+
+    auto input_buffer = boost::asio::buffer(input);
+    bp::async_pipe input_pipe(ios);
+    std::vector<char> output_buffer(MAX_GAME_RESPONSE_B);
+
+    bp::child c(
+        system_complete(game.logic_file), bp::start_dir(game.directory),
+        bp::std_in<input_pipe, bp::std_out> boost::asio::buffer(output_buffer),
+        ios);
+
+    boost::asio::async_write(
+        input_pipe, input_buffer,
+        [&input_pipe](const boost::system::error_code &ec, std::size_t n) {
+            input_pipe.async_close();
+        });
+
+    ios.run();
+
+    if (!c.wait_for(std::chrono::milliseconds{LOGIC_TIMEOUT_MS})) {
+        LOG_ERROR << game.logic_file.string() << " logic executable timeout ("
+                  << LOGIC_TIMEOUT_MS << " ms) exceeded";
+        c.terminate();
+    }
+
+    return std::string(output_buffer.begin(), output_buffer.end());
+}
+
+cavoke::ValidationResult GameLogicManager::validate_settings(
+    const std::string &game_id,
+    const json &settings,
+    const std::vector<int> &occupied_positions) {
+    std::optional<Game> game_info = m_games_storage->get_game_by_id(game_id);
+    if (!game_info.has_value()) {
+        throw validation_error("no game with id '" + game_id + "'");
+    }
+
+    std::string response;
+
+    if (game_info->config.app_type == "LOCAL") {
+        std::ostringstream request;
+        request << "VALIDATE ";
+        json request_data = InitSettings{settings, occupied_positions};
+        request << request_data;
+        response = invoke_logic_local(game_info.value(), request.str());
+    } else if (game_info->config.app_type == "EXTERNAL") {
+        response = invoke_logic_external(
+            game_info.value(), "validate",
+            json(InitSettings{settings, occupied_positions}).dump());
+    }
+
+    json response_json = json::parse(response);
+    auto result = response_json.get<ValidationResult>();
+
+    return result;
+}
+
+GameStateStorage::GameState GameLogicManager::init_state(
+    const std::string &game_id,
+    const json &settings,
+    const std::vector<int> &occupied_positions) {
+    std::optional<Game> game_info = m_games_storage->get_game_by_id(game_id);
+    if (!game_info.has_value()) {
+        return {};
+    }
+
+    std::string response;
+
+    if (game_info->config.app_type == "LOCAL") {
+        std::ostringstream request;
+        request << "INIT ";
+        json request_data = InitSettings{settings, occupied_positions};
+        request << request_data;
+        response = invoke_logic_local(game_info.value(), request.str());
+    } else if (game_info->config.app_type == "EXTERNAL") {
+        response = invoke_logic_external(
+            game_info.value(), "init_state",
+            json(InitSettings{settings, occupied_positions}).dump());
+    }
+
+    json response_json = json::parse(response);
+    auto result = response_json.get<GameStateStorage::GameState>();
+
+    return result;
+}
+
+GameStateStorage::GameState GameLogicManager::send_move(
+    const std::string &game_id,
+    const cavoke::GameMove &move) {
+    std::optional<Game> game_info = m_games_storage->get_game_by_id(game_id);
+    if (!game_info.has_value()) {
+        return {};
+    }
+
+    std::string response;
+
+    if (game_info->config.app_type == "LOCAL") {
+        std::ostringstream request;
+        request << "MOVE ";
+        json request_data = move;
+        request << request_data;
+        response = invoke_logic_local(game_info.value(), request.str());
+    } else if (game_info->config.app_type == "EXTERNAL") {
+        response = invoke_logic_external(game_info.value(), "apply_move",
+                                         json(move).dump());
+    }
+
+    json response_json = json::parse(response);
+    auto result = response_json.get<GameStateStorage::GameState>();
+
+    return result;
+}
+
+std::string GameLogicManager::invoke_logic_external(const Game &game,
+                                                    const std::string &method,
+                                                    const std::string &input) {
+    auto client = drogon::HttpClient::newHttpClient(game.config.url,
+                                                    drogon::app().getLoop());
+    auto request = drogon::HttpRequest::newHttpRequest();
+    request->setPath("/" + method);
+    request->setMethod(drogon::Post);
+    request->setBody(input);
+    auto result = client->sendRequest(request, 30.0);
+
+    if (result.first != drogon::ReqResult::Ok) {
+        LOG_ERROR << "Failed to connect with game logic on address "
+                  << game.config.url << " " << request->getPath() << ": "
+                  << to_string(result.first);
+        return "";
+    }
+
+    return std::string(result.second->getBody());
+}
+
+validation_error::validation_error(std::string message)
+    : cavoke_base_exception(std::move(message),
+                            InvalidConfig,
+                            "cavoke/validation") {
+}
+
+}  // namespace cavoke::server::model
diff --git a/server/model/logic/game_logic_manager.h b/server/model/logic/game_logic_manager.h
new file mode 100644
index 00000000..7d9ecba4
--- /dev/null
+++ b/server/model/logic/game_logic_manager.h
@@ -0,0 +1,47 @@
+#ifndef CAVOKE_SERVER_GAME_LOGIC_MANAGER_H
+#define CAVOKE_SERVER_GAME_LOGIC_MANAGER_H
+
+#include <memory>
+#include <string>
+#include "cavoke.h"
+#include "game_state_storage.h"
+#include "model/games/games_storage.h"
+
+namespace cavoke::server::model {
+
+/// is thrown when trying to start a new session with invalid config
+struct validation_error : cavoke_base_exception {
+    explicit validation_error(std::string message);
+};
+
+class GameLogicManager {
+    std::shared_ptr<GamesStorage> m_games_storage;
+
+    std::string invoke_logic_local(const Game &game, const std::string &input);
+    std::string invoke_logic_external(const Game &game,
+                                      const std::string &method,
+                                      const std::string &input);
+
+public:
+    explicit GameLogicManager(std::shared_ptr<GamesStorage> games_storage);
+
+    const int LOGIC_TIMEOUT_MS = 500;
+    const int MAX_GAME_RESPONSE_B = 8 * 1024;
+
+    ValidationResult validate_settings(
+        const std::string &game_id,
+        const json &settings,
+        const std::vector<int> &occupied_positions);
+
+    GameStateStorage::GameState init_state(
+        const std::string &game_id,
+        const json &settings,
+        const std::vector<int> &occupied_positions);
+
+    GameStateStorage::GameState send_move(const std::string &game_id,
+                                          const cavoke::GameMove &move);
+};
+
+}  // namespace cavoke::server::model
+
+#endif  // CAVOKE_SERVER_GAME_LOGIC_MANAGER_H
diff --git a/server/model/logic/game_state_storage.cpp b/server/model/logic/game_state_storage.cpp
new file mode 100644
index 00000000..2413c4dd
--- /dev/null
+++ b/server/model/logic/game_state_storage.cpp
@@ -0,0 +1,101 @@
+#include "game_state_storage.h"
+#include <drogon/HttpAppFramework.h>
+#include <json/reader.h>
+#include <utility>
+#include "sql-models/Globalstates.h"
+#include "sql-models/Players.h"
+#include "utils.h"
+
+namespace cavoke::server::model {
+
+using json = nlohmann::json;
+using namespace drogon::orm;
+
+void GameStateStorage::save_state(const std::string &session_id,
+                                  GameStateStorage::GameState new_state,
+                                  DbClientPtr dbClient) {
+    auto mp_globalstates = MAPPER_WITH_CLIENT_FOR(
+        drogon_model::cavoke_orm::Globalstates, dbClient);
+    auto mp_players =
+        MAPPER_WITH_CLIENT_FOR(drogon_model::cavoke_orm::Players, dbClient);
+
+    auto global_state = mp_globalstates.findOne(
+        Criteria(drogon_model::cavoke_orm::Globalstates::Cols::_session_id,
+                 CompareOperator::EQ, session_id));
+    auto players = mp_players.findBy(
+        Criteria(drogon_model::cavoke_orm::Players::Cols::_session_id,
+                 CompareOperator::EQ, session_id));
+
+    global_state.setGlobalstate(new_state.global_state);
+    global_state.setIsTerminal(new_state.is_terminal);
+
+    for (auto &player : players) {
+        player.setPlayerstate(
+            new_state.players_state[player.getValueOfPlayerId()]);
+        if (new_state.is_terminal) {
+            // FIXME: move to a new winner system
+            bool is_winner =
+                std::any_of(new_state.winners.begin(), new_state.winners.end(),
+                            [&](int player_id) {
+                                return player.getValueOfPlayerId() == player_id;
+                            });
+            player.setScore(is_winner ? 1 : 0);
+        } else {
+            player.setScoreToNull();
+        }
+        mp_players.update(player);
+    }
+    mp_globalstates.update(global_state);
+}
+
+GameStateStorage::GameState GameStateStorage::get_state(
+    const std::string &session_id,
+    drogon::orm::DbClientPtr dbClient) {
+    GameStateStorage::GameState state;
+
+    auto mp_globalstates = MAPPER_WITH_CLIENT_FOR(
+        drogon_model::cavoke_orm::Globalstates, dbClient);
+    auto global_state = mp_globalstates.findOne(drogon::orm::Criteria(
+        drogon_model::cavoke_orm::Globalstates::Cols::_session_id,
+        drogon::orm::CompareOperator::EQ, session_id));
+    state.global_state = global_state.getValueOfGlobalstate();
+    state.is_terminal = global_state.getValueOfIsTerminal();
+
+    auto mp_players =
+        MAPPER_WITH_CLIENT_FOR(drogon_model::cavoke_orm::Players, dbClient);
+    auto players = mp_players.findBy(drogon::orm::Criteria(
+        drogon_model::cavoke_orm::Players::Cols::_session_id,
+        drogon::orm::CompareOperator::EQ, session_id));
+    state.players_state = std::vector<std::string>(players.size());
+    for (auto &player : players) {
+        int player_id = player.getValueOfPlayerId();
+        if (player.getScore()) {
+            state.winners.push_back(player_id);
+        }
+        state.players_state[player_id] = player.getValueOfPlayerstate();
+    }
+    return state;
+}
+
+std::string GameStateStorage::get_player_state(const std::string &session_id,
+                                               int player_id) {
+    auto mp_players = MAPPER_FOR(drogon_model::cavoke_orm::Players);
+    try {
+        auto player = mp_players.findOne(
+            Criteria(drogon_model::cavoke_orm::Players::Cols::_session_id,
+                     CompareOperator::EQ, session_id) &&
+            Criteria(drogon_model::cavoke_orm::Players::Cols::_player_id,
+                     CompareOperator::EQ, player_id));
+        return player.getValueOfPlayerstate();
+    } catch (const std::out_of_range &) {
+        throw game_state_error("There's no player '" +
+                               std::to_string(player_id) + "' in session '" +
+                               session_id + "'");
+    }
+}
+
+game_state_error::game_state_error(std::string message)
+    : cavoke_base_exception(std::move(message), NotFound, "cavoke/state") {
+}
+
+}  // namespace cavoke::server::model
diff --git a/server/model/game_state_storage.h b/server/model/logic/game_state_storage.h
similarity index 50%
rename from server/model/game_state_storage.h
rename to server/model/logic/game_state_storage.h
index a60f07e4..a51653d0 100644
--- a/server/model/game_state_storage.h
+++ b/server/model/logic/game_state_storage.h
@@ -1,15 +1,25 @@
 #ifndef CAVOKE_SERVER_GAME_STATE_STORAGE_H
 #define CAVOKE_SERVER_GAME_STATE_STORAGE_H
 
+#include <drogon/HttpAppFramework.h>
+#include <drogon/orm/DbClient.h>
 #include <map>
+#include <mutex>
 #include <nlohmann/json.hpp>
 #include <optional>
+#include <shared_mutex>
 #include <string>
 #include <vector>
+#include "cavoke_base_exception.h"
 
 namespace cavoke::server::model {
 
-class GameStateStorage {  // TODO: thread safety
+/// exception for errors thrown during actions with game states
+struct game_state_error : cavoke_base_exception {
+    explicit game_state_error(std::string message);
+};
+
+class GameStateStorage {
 public:
     struct GameState {
         bool is_terminal;
@@ -18,17 +28,16 @@ class GameStateStorage {  // TODO: thread safety
         std::vector<int> winners;
     };
 
-    static GameState parse_state(const std::string &s);
-
-    void save_state(const std::string &session_id, GameState new_state);
-
-    std::optional<GameState> get_state(const std::string &session_id);
+    void save_state(
+        const std::string &session_id,
+        GameStateStorage::GameState new_state,
+        drogon::orm::DbClientPtr dbClient = drogon::app().getDbClient());
 
-    std::optional<std::string> get_player_state(const std::string &session_id,
-                                                int player_id);
+    GameState get_state(
+        const std::string &session_id,
+        drogon::orm::DbClientPtr dbClient = drogon::app().getDbClient());
 
-private:
-    std::map<std::string, GameState> m_states;
+    std::string get_player_state(const std::string &session_id, int player_id);
 };
 
 NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameStateStorage::GameState,
diff --git a/server/model/rooms/rooms_storage.cpp b/server/model/rooms/rooms_storage.cpp
new file mode 100644
index 00000000..29b932ba
--- /dev/null
+++ b/server/model/rooms/rooms_storage.cpp
@@ -0,0 +1,197 @@
+#include "rooms_storage.h"
+#include <utility>
+#include "drogon/orm/Criteria.h"
+#include "sql-models/RoomJoins.h"
+
+namespace cavoke::server::model {
+
+using namespace drogon::orm;
+
+RoomsStorage::RoomsStorage(std::shared_ptr<SessionsStorage> mSessionsStorage)
+    : m_sessions_storage(std::move(mSessionsStorage)) {
+}
+
+/// Generates an invite code for session
+std::string RoomsStorage::generate_invite_code() {
+    // prepare template
+    std::string res = "......";
+    // random digits
+    std::random_device rd;
+    std::mt19937 engine(rd());
+    std::uniform_int_distribution<char> dist('0', '9');
+    // set every character to be a random digit
+    std::generate(res.begin(), res.end(),
+                  [&dist, &engine]() { return dist(engine); });
+    return res;
+}
+
+std::optional<RoomsStorage::RoomInfo> RoomsStorage::get_by_id(
+    const std::string &room_id) {
+    auto mp_rooms_trans = MAPPER_FOR(drogon_model::cavoke_orm::Rooms);
+    try {
+        const auto &room = mp_rooms_trans.findByPrimaryKey(room_id);
+        const auto &members = get_members(room_id);
+        return RoomInfo::from_room_and_members(room, members);
+    } catch (const UnexpectedRows &e) {
+        return std::nullopt;
+    }
+}
+
+std::vector<GameSessionAccessObject::UserInfo> RoomsStorage::get_members(
+    const std::string &room_id) {
+    auto mp_rooms_trans = MAPPER_FOR(drogon_model::cavoke_orm::Rooms);
+    auto mp_joins_trans = MAPPER_FOR(drogon_model::cavoke_orm::RoomJoins);
+    auto mp_users_trans = MAPPER_FOR(
+        drogon_model::cavoke_orm::Users);  // !!! we need a users controller !!!
+
+    auto joins = mp_joins_trans.findBy(
+        Criteria(drogon_model::cavoke_orm::RoomJoins::Cols::_room_id,
+                 CompareOperator::EQ, room_id));
+
+    std::vector<GameSessionAccessObject::UserInfo> members;
+    members.reserve(joins.size());
+    std::transform(
+        joins.begin(), joins.end(), std::back_inserter(members),
+        [&mp_users_trans](const drogon_model::cavoke_orm::RoomJoins &join) {
+            return GameSessionAccessObject::UserInfo::from_user(
+                mp_users_trans.findByPrimaryKey(join.getValueOfUserId()));
+        });
+
+    return members;
+}
+
+std::optional<RoomsStorage::RoomInfo> RoomsStorage::get_by_invite_code(
+    const std::string &invite_code) {
+    auto transaction = drogon::app().getDbClient()->newTransaction();
+    auto mp_rooms_trans = MAPPER_FOR(drogon_model::cavoke_orm::Rooms);
+    try {
+        const auto &room = mp_rooms_trans.findOne(
+            Criteria(drogon_model::cavoke_orm::Rooms::Cols::_invite_code,
+                     CompareOperator::EQ, invite_code));
+        const auto &members = get_members(room.getValueOfId());
+        return RoomInfo::from_room_and_members(room, members);
+
+    } catch (const UnexpectedRows &) {
+        return std::nullopt;
+    }
+}
+
+void RoomsStorage::add_user(const std::string &room_id,
+                            const std::string &user_id) {
+    if (is_member(room_id, user_id)) {
+        return;
+    }
+
+    if (!get_by_id(room_id).has_value()) {
+        throw room_error("Cannot add user. No room with id " + room_id);
+    }
+
+    auto join = drogon_model::cavoke_orm::RoomJoins();
+    {
+        join.setRoomId(room_id);
+        join.setUserId(user_id);
+    }
+
+    auto mp_joins_trans = MAPPER_FOR(drogon_model::cavoke_orm::RoomJoins);
+    mp_joins_trans.insert(join);
+}
+
+void RoomsStorage::remove_user(const std::string &room_id,
+                               const std::string &user_id) {
+    if (!is_member(room_id, user_id)) {
+        return;
+    }
+    drogon::app().getDbClient()->execSqlSync(
+        "select leave_room($1::uuid, $2::varchar);", room_id, user_id);
+}
+
+bool RoomsStorage::is_member(const std::string &room_id,
+                             const std::string &user_id) {
+    auto mp_joins_trans = MAPPER_FOR(drogon_model::cavoke_orm::RoomJoins);
+    size_t joins_count = mp_joins_trans.count(
+        Criteria(drogon_model::cavoke_orm::RoomJoins::Cols::_room_id,
+                 CompareOperator::EQ, room_id) &&
+        Criteria(drogon_model::cavoke_orm::RoomJoins::Cols::_user_id,
+                 CompareOperator::EQ, user_id));
+    return joins_count > 0;
+}
+
+RoomsStorage::RoomInfo RoomsStorage::create_room(
+    const std::string &host_id,
+    const std::string &display_name) {
+    auto room = drogon_model::cavoke_orm::Rooms();
+    {
+        room.setId(drogon::utils::getUuid());
+        // TODO: there are only 1e6 invite codes, something has to be done about
+        room.setInviteCode(generate_invite_code());
+        room.setDisplayName(display_name);
+        room.setSessionIdToNull();
+    }
+
+    auto join = drogon_model::cavoke_orm::RoomJoins();
+    {
+        join.setRoomId(room.getValueOfId());
+        join.setUserId(host_id);
+    }
+
+    {
+        //        auto transaction =
+        //        drogon::app().getDbClient()->newTransaction();
+        auto mp_rooms_trans = MAPPER_FOR(drogon_model::cavoke_orm::Rooms);
+        auto mp_joins_trans = MAPPER_FOR(drogon_model::cavoke_orm::RoomJoins);
+
+        mp_rooms_trans.insert(room);
+        mp_joins_trans.insert(join);
+
+        room.setHostId(host_id);
+        mp_rooms_trans.update(room);
+    }
+
+    return RoomsStorage::RoomInfo::from_room_and_members(
+        room, get_members(room.getValueOfId()));
+}
+
+GameSessionAccessObject::GameSessionInfo RoomsStorage::create_session(
+    const std::string &room_id,
+    const GameConfig &game_config) {
+    auto opt_room_info = get_by_id(room_id);
+    if (!opt_room_info.has_value()) {
+        throw room_error("Cannot create session. No room with id " + room_id);
+    }
+    auto room_info = opt_room_info.value();
+
+    if (!room_info.session_id.empty()) {
+        auto current_session =
+            m_sessions_storage->get_sessionAO(room_info.session_id);
+        if (current_session.get_session_info().status !=
+            GameSessionAccessObject::SessionStatus::FINISHED) {
+            throw room_error("Cannot create session in room " + room_id +
+                             ". Session already exists and not "
+                             "finished.");
+        }
+    }
+
+    auto new_session = m_sessions_storage->create_session(
+        game_config, room_info.host_id, room_id);
+
+    return new_session;
+}
+
+room_error::room_error(std::string message)
+    : cavoke_base_exception(std::move(message),
+                            InvalidClientInput,
+                            "cavoke/rooms") {
+}
+
+RoomsStorage::RoomInfo RoomsStorage::RoomInfo::from_room_and_members(
+    const drogon_model::cavoke_orm::Rooms &room_orm,
+    const std::vector<GameSessionAccessObject::UserInfo> &members) {
+    return {room_orm.getValueOfId(),
+            room_orm.getValueOfInviteCode(),
+            room_orm.getValueOfDisplayName(),
+            room_orm.getValueOfSessionId(),
+            {},
+            room_orm.getValueOfHostId(),
+            members};
+}
+}  // namespace cavoke::server::model
diff --git a/server/model/rooms/rooms_storage.h b/server/model/rooms/rooms_storage.h
new file mode 100644
index 00000000..43d43867
--- /dev/null
+++ b/server/model/rooms/rooms_storage.h
@@ -0,0 +1,69 @@
+#ifndef CAVOKE_ROOMS_STORAGE_H
+#define CAVOKE_ROOMS_STORAGE_H
+
+#include <memory>
+#include "model/sessions/game_session.h"
+#include "model/sessions/sessions_storage.h"
+#include "sql-models/Rooms.h"
+
+namespace cavoke::server::model {
+
+/// exception for errors thrown during actions with rooms
+struct room_error : cavoke_base_exception {
+    explicit room_error(std::string message);
+};
+
+class RoomsStorage {
+    std::shared_ptr<SessionsStorage> m_sessions_storage;
+
+    static std::string generate_invite_code();
+
+public:
+    explicit RoomsStorage(std::shared_ptr<SessionsStorage> mSessionsStorage);
+
+    struct RoomInfo {
+        std::string room_id;
+        std::string invite_code;
+        std::string display_name;
+        std::string session_id;  // let "" mean null
+        GameSessionAccessObject::GameSessionInfo session;
+        std::string host_id;
+        std::vector<GameSessionAccessObject::UserInfo> members;
+
+        static RoomInfo from_room_and_members(
+            const drogon_model::cavoke_orm::Rooms &room_orm,
+            const std::vector<GameSessionAccessObject::UserInfo> &members);
+    };
+
+    std::vector<GameSessionAccessObject::UserInfo> get_members(
+        const std::string &room_id);
+
+    std::optional<RoomInfo> get_by_id(const std::string &room_id);
+
+    std::optional<RoomInfo> get_by_invite_code(const std::string &invite_code);
+
+    RoomInfo create_room(const std::string &host_id,
+                         const std::string &display_name);
+
+    void add_user(const std::string &room_id, const std::string &user_id);
+
+    void remove_user(const std::string &room_id, const std::string &user_id);
+
+    bool is_member(const std::string &room_id, const std::string &user_id);
+
+    GameSessionAccessObject::GameSessionInfo create_session(
+        const std::string &room_id,
+        const GameConfig &game_config);
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(RoomsStorage::RoomInfo,
+                                   room_id,
+                                   invite_code,
+                                   display_name,
+                                   session_id,
+                                   session,
+                                   host_id,
+                                   members)
+
+}  // namespace cavoke::server::model
+#endif  // CAVOKE_ROOMS_STORAGE_H
diff --git a/server/model/sessions/game_session.cpp b/server/model/sessions/game_session.cpp
index accaecb3..8de6a342 100644
--- a/server/model/sessions/game_session.cpp
+++ b/server/model/sessions/game_session.cpp
@@ -1,100 +1,265 @@
 #include "game_session.h"
-cavoke::server::model::game_session_error::game_session_error(
-    std::string message)
+
+namespace cavoke::server::model {
+using namespace drogon::orm;
+
+game_session_error::game_session_error(std::string message)
     : cavoke_base_exception(std::move(message),
                             InvalidClientInput,
                             "cavoke/sessions") {
 }
-cavoke::server::model::GameSession::GameSession(
-    cavoke::server::model::GameConfig game_config,
-    std::optional<json> game_settings)
-    : id(drogon::utils::getUuid()),
-      m_game_config(std::move(game_config)),
-      m_invite_code(generate_invite_code()) {
-    if (game_settings.has_value()) {
-        m_game_settings = game_settings.value();
-    } else {
-        m_game_settings = m_game_config.default_settings;
-    }
-}
+
 /**
  * Adds given user to session.
- * Throws an exception if user already in this session or too many players in a
- * session
+ * Throws an exception if user already in this session, session has already
+ * started or too many players in a session
  */
-void cavoke::server::model::GameSession::add_user(const std::string &user_id) {
-    // TODO: thread-safety
-    if (m_userid_to_playerid.left.count(user_id) != 0) {
+void GameSessionAccessObject::add_user(const std::string &user_id,
+                                       std::optional<int> player_id) {
+    auto session_snapshot = get_snapshot();
+    if (get_actual_status().getValueOfStatus() != NOT_STARTED) {
+        throw game_session_error("session has already started");
+    }
+
+    if (0 != default_mp_players.count(
+                 Criteria(drogon_model::cavoke_orm::Players::Cols::_session_id,
+                          CompareOperator::EQ, id) &&
+                 Criteria(drogon_model::cavoke_orm::Players::Cols::_user_id,
+                          CompareOperator::EQ, user_id))) {
         return;
     }
     // get player id for user
-    int pos = static_cast<int>(m_userid_to_playerid.size());
-    if (pos >= m_game_config.players_num) {
-        throw game_session_error("maximum number of players reached");
+    int pos;
+    if (player_id.has_value()) {
+        pos = player_id.value();
+    } else {
+        std::set<int> possible_positions;
+        for (int candidate_pos = 0; candidate_pos < m_game_config.players_num;
+             ++candidate_pos) {
+            possible_positions.insert(candidate_pos);
+        }
+        for (int occupied_pos : get_occupied_positions()) {
+            possible_positions.erase(occupied_pos);
+        }
+        if (possible_positions.empty()) {
+            throw game_session_error("maximum number of players reached");
+        }
+        pos = *possible_positions.begin();
+    }
+    try {
+        drogon_model::cavoke_orm::Players new_player;
+        new_player.setUserId(user_id);
+        new_player.setSessionId(id);
+        new_player.setScoreToNull();
+        new_player.setPlayerId(pos);
+        new_player.setPlayerstate("");
+        default_mp_players.insert(new_player);
+        LOG_DEBUG << "Added: " << user_id << " with player_id=" << pos << " to "
+                  << id;
+    } catch (const DrogonDbException &) {
+        throw game_session_error("position is already occupied");
     }
-    // add user to session
-    auto [_, suc] = m_userid_to_playerid.insert({user_id, pos});
-    std::cout << suc << std::endl;
 }
+
 /**
  * Gets player id for user.
  * Throws an exception if user not in this session
  */
-int cavoke::server::model::GameSession::get_player_id(
-    const std::string &user_id) const {
+int GameSessionAccessObject::get_player_id(const std::string &user_id) const {
     try {
-        return m_userid_to_playerid.left.at(user_id);
-    } catch (const std::out_of_range &) {  // slow?
+        return default_mp_players
+            .findOne(
+                Criteria(drogon_model::cavoke_orm::Players::Cols::_session_id,
+                         CompareOperator::EQ, id) &&
+                Criteria(drogon_model::cavoke_orm::Players::Cols::_user_id,
+                         CompareOperator::EQ, user_id))
+            .getValueOfPlayerId();
+    } catch (const UnexpectedRows &) {
         throw game_session_error("user not in session");
     }
 }
+
 /**
  * Gets user id for player.
  * Throws an exception if player not in this session
  */
-std::string cavoke::server::model::GameSession::get_user_id(
-    int player_id) const {
+std::string GameSessionAccessObject::get_user_id(int player_id) const {
     try {
-        return m_userid_to_playerid.right.at(player_id);
-    } catch (const std::out_of_range &) {  // slow?
-        throw game_session_error("player not in session");
+        return default_mp_players
+            .findOne(
+                Criteria(drogon_model::cavoke_orm::Players::Cols::_session_id,
+                         CompareOperator::EQ, id) &&
+                Criteria(drogon_model::cavoke_orm::Players::Cols::_player_id,
+                         CompareOperator::EQ, player_id))
+            .getValueOfUserId();
+    } catch (const UnexpectedRows &) {
+        throw game_session_error("user not in session");
     }
 }
-/// Validates the invite code for this session
-bool cavoke::server::model::GameSession::verify_invite_code(
-    const std::string &invite_code) const {
-    return invite_code == m_invite_code;
-}
+
 /// Generates an info object (representation for client)
-cavoke::server::model::GameSession::GameSessionInfo
-cavoke::server::model::GameSession::get_session_info() const {
-    return {id, m_game_config.id, m_invite_code};
-}
-/// Generates an invite code for session
-std::string cavoke::server::model::GameSession::generate_invite_code() {
-    // prepare template
-    std::string res = "......";
-    // random digits
-    std::random_device rd;
-    std::mt19937 engine(rd());
-    std::uniform_int_distribution<char> dist('0', '9');
-    // set every character to be a random digit
-    std::generate(res.begin(), res.end(),
-                  [&dist, &engine]() { return dist(engine); });
-    return res;
-}
-
-std::vector<int> cavoke::server::model::GameSession::get_occupied_positions()
-    const {
+GameSessionAccessObject::GameSessionInfo
+GameSessionAccessObject::get_session_info() const {
+    auto session_snapshot = get_snapshot();
+    return make_session_info(session_snapshot, get_actual_status(),
+                             get_players());
+}
+
+std::vector<int> GameSessionAccessObject::get_occupied_positions() const {
     std::vector<int> result;
-    for (const auto &e : m_userid_to_playerid) {
+    for (const auto &player : default_mp_players.findBy(
+             Criteria(drogon_model::cavoke_orm::Players::Cols::_session_id,
+                      CompareOperator::EQ, id))) {
         // cppcheck-suppress useStlAlgorithm
-        result.push_back(e.right);
+        result.push_back(player.getValueOfPlayerId());
     }
     return result;
 }
 
-const cavoke::server::model::json &
-cavoke::server::model::GameSession::get_game_settings() const {
-    return m_game_settings;
+// std::optional<json> &GameSessionAccessObject::get_game_settings() const {
+//     auto session = get_snapshot();
+//     auto settings_ptr = session.getGameSettings();
+//     return *settings_ptr;
+// }
+
+std::vector<GameSessionAccessObject::PlayerInfo>
+GameSessionAccessObject::get_players() const {
+    auto players = default_mp_players.findBy(
+        Criteria(drogon_model::cavoke_orm::Players::Cols::_session_id,
+                 CompareOperator::EQ, id));
+    auto users_in_session_result = drogon::app().getDbClient()->execSqlSync(
+        "select u.*, player_id from players join users u on players.user_id = "
+        "u.id and players.session_id = $1",
+        id);
+    std::map<int, drogon_model::cavoke_orm::Users> users;
+    for (auto &r : users_in_session_result) {
+        int player_id = r["player_id"].as<int>();
+        users[player_id] = drogon_model::cavoke_orm::Users(r);
+    }
+    std::vector<PlayerInfo> result;
+    std::transform(
+        players.begin(), players.end(), std::back_inserter(result),
+        [&users](const drogon_model::cavoke_orm::Players &player) {
+            int player_id = player.getValueOfPlayerId();
+            return PlayerInfo{UserInfo::from_user(users[player_id]), player_id};
+        });
+    return result;
 }
+
+void GameSessionAccessObject::start(const json &game_settings) {
+    auto session = default_mp_sessions.findOne(
+        Criteria(drogon_model::cavoke_orm::Sessions::Cols::_id,
+                 CompareOperator::EQ, id));
+    // FIXME: not atomic, transactions perhaps or some other blocking
+    // sql-mechanism?
+    if (get_actual_status().getValueOfStatus() != NOT_STARTED) {
+        throw game_session_error("session has already started");
+    }
+    session.setGameSettings(game_settings.dump());
+    set_status(RUNNING);
+    default_mp_sessions.update(session);
+}
+
+bool GameSessionAccessObject::is_player(const std::string &user_id) const {
+    try {
+        [[maybe_unused]] int tmp = get_player_id(user_id);
+        return true;
+    } catch (const game_session_error &) {
+        return false;
+    }
+}
+
+std::string GameSessionAccessObject::get_host() const {
+    return get_snapshot().getValueOfHostId();
+}
+
+bool GameSessionAccessObject::is_host(const std::string &user_id) const {
+    return get_host() == user_id;
+}
+
+void GameSessionAccessObject::finish() {
+    set_status(FINISHED);
+}
+drogon_model::cavoke_orm::Sessions GameSessionAccessObject::get_snapshot()
+    const {
+    return default_mp_sessions.findOne(
+        Criteria(drogon_model::cavoke_orm::Sessions::Cols::_id,
+                 CompareOperator::EQ, id));
+}
+drogon_model::cavoke_orm::Sessions GameSessionAccessObject::get_snapshot(
+    const std::string &session_id) {
+    auto mp_sessions = MAPPER_FOR(drogon_model::cavoke_orm::Sessions);
+    return mp_sessions.findOne(
+        Criteria(drogon_model::cavoke_orm::Sessions::Cols::_id,
+                 drogon::orm::CompareOperator::EQ, session_id));
+}
+
+GameSessionAccessObject::GameSessionInfo
+GameSessionAccessObject::make_session_info(
+    const drogon_model::cavoke_orm::Sessions &session,
+    const drogon_model::cavoke_orm::Statuses &status,
+    std::vector<PlayerInfo> players) {
+    return {session.getValueOfId(), session.getValueOfGameId(),
+            session.getValueOfHostId(),
+            static_cast<SessionStatus>(status.getValueOfStatus()),
+            std::move(players)};
+}
+
+void GameSessionAccessObject::remove_user(const std::string &user_id) {
+    if (get_actual_status().getValueOfStatus() != NOT_STARTED) {
+        throw game_session_error("session has already started");
+    }
+
+    default_mp_players.deleteBy(
+        Criteria(drogon_model::cavoke_orm::Players::Cols::_user_id,
+                 CompareOperator::EQ, user_id));
+}
+
+void GameSessionAccessObject::set_role(const std::string &user_id,
+                                       int new_role) {
+    // check role's validity
+    if (!(0 <= new_role && new_role < m_game_config.players_num)) {
+        throw game_session_error("no such role " + std::to_string(new_role));
+    }
+    try {
+        // INFO: does not differentiate the following cases: user not in this
+        // session, user in this session changes his role to his current one
+        default_mp_players.updateBy(
+            {drogon_model::cavoke_orm::Players::Cols::_player_id},
+            Criteria(drogon_model::cavoke_orm::Players::Cols::_user_id,
+                     CompareOperator::EQ, user_id),
+            new_role);
+    } catch (const std::exception &err) {
+        throw game_session_error("could not update role for player");
+    }
+}
+
+void GameSessionAccessObject::delete_session() {
+    default_mp_sessions.deleteBy(
+        Criteria(drogon_model::cavoke_orm::Sessions::Cols::_id,
+                 CompareOperator::EQ, id));
+}
+
+void GameSessionAccessObject::leave_session(const std::string &user_id) {
+    drogon::app().getDbClient()->execSqlSync(
+        "select leave_session($1::uuid, $2::varchar);", id, user_id);
+}
+
+drogon_model::cavoke_orm::Statuses GameSessionAccessObject::get_actual_status()
+    const {
+    return default_mp_statuses
+        .orderBy(drogon_model::cavoke::Statuses::Cols::_saved_on,
+                 SortOrder::DESC)
+        .findBy(Criteria(drogon_model::cavoke_orm::Statuses::Cols::_session_id,
+                         CompareOperator::EQ, id))[0];
+}
+
+void GameSessionAccessObject::set_status(SessionStatus status) {
+    drogon_model::cavoke::Statuses status_record;
+    auto session = get_snapshot();
+    status_record.setSessionId(session.getValueOfId());
+    status_record.setStatus(status);
+    default_mp_statuses.insert(status_record);
+}
+
+}  // namespace cavoke::server::model
diff --git a/server/model/sessions/game_session.h b/server/model/sessions/game_session.h
index b137bf6b..64c7049a 100644
--- a/server/model/sessions/game_session.h
+++ b/server/model/sessions/game_session.h
@@ -1,14 +1,21 @@
 #ifndef CAVOKE_GAME_SESSION_H
 #define CAVOKE_GAME_SESSION_H
 
+#include <drogon/HttpAppFramework.h>
 #include <drogon/utils/Utilities.h>
 #include <boost/bimap.hpp>
 #include <map>
 #include <random>
+#include <shared_mutex>
 #include <string>
 #include <utility>
+#include "cavoke.h"
 #include "cavoke_base_exception.h"
-#include "model/game.h"
+#include "model/games/game.h"
+#include "sql-models/Players.h"
+#include "sql-models/Sessions.h"
+#include "sql-models/Statuses.h"
+#include "sql-models/Users.h"
 
 namespace cavoke::server::model {
 
@@ -17,48 +24,132 @@ struct game_session_error : cavoke_base_exception {
     explicit game_session_error(std::string message);
 };
 
-struct GameSession {
-    explicit GameSession(GameConfig game_config,
-                         std::optional<json> game_settings = {});
-    GameSession() =
-        default;  // FIXME: required by map in `sessions_storage.cpp`
-
-    void add_user(const std::string &user_id);
+/// Access object for a game session.
+/// The fields of sessions may be spontaneously changed in another instance
+/// of the server. Therefore this class only provides methods to fetch DB data.
+/// Drogon ORM struct serves as the data holder.
+struct GameSessionAccessObject {
+    enum SessionStatus { NOT_STARTED = 0, RUNNING = 1, FINISHED = 2 };
+    explicit GameSessionAccessObject(
+        drogon::orm::DbClientPtr dbClient = drogon::app().getDbClient())
+        : dbClient(std::move(dbClient)) {
+    }
+    explicit GameSessionAccessObject(
+        std::string session_id,
+        GameConfig game_config,
+        drogon::orm::DbClientPtr dbClient = drogon::app().getDbClient())
+        : id(std::move(session_id)),
+          m_game_config(std::move(game_config)),
+          dbClient(std::move(dbClient)) {
+    }
+
+    /// Adds given user to the session into given or minimal available position
+    void add_user(const std::string &user_id,
+                  std::optional<int> player_id = {});
+
+    /// Removes given user
+    void remove_user(const std::string &user_id);
+
+    /// Changes game role for given user
+    void set_role(const std::string &user_id, int new_role);
+
+    /// Delete current session
+    void delete_session();
+
+    /// Leave current session (and transfer host/delete session)
+    void leave_session(const std::string &user_id);
+
+    /// Marks session as starts
+    void start(const json &game_settings);
+
+    /// Marks sessions as finished
+    void finish();
 
     [[nodiscard]] int get_player_id(const std::string &user_id) const;
 
+    [[nodiscard]] std::string get_host() const;
+
+    [[nodiscard]] bool is_player(const std::string &user_id) const;
+
+    [[nodiscard]] bool is_host(const std::string &user_id) const;
+
     [[nodiscard]] std::string get_user_id(int player_id) const;
 
-    [[nodiscard]] bool verify_invite_code(const std::string &invite_code) const;
+    struct UserInfo {
+        std::string user_id;
+        std::string display_name;
+
+        static UserInfo from_user(const drogon_model::cavoke_orm::Users &user) {
+            return {user.getValueOfId(), user.getValueOfDisplayName()};
+        }
+    };
+
+    /// Serializable representation of participant for client
+    struct PlayerInfo {
+        UserInfo user;
+        int player_id;
+    };
 
     /// Serializable representation of session for client
     struct GameSessionInfo {
         std::string session_id;
         std::string game_id;
-        std::string invite_code;
+        std::string host_id;
+        SessionStatus status;
+        std::vector<PlayerInfo> players;
     };
 
     [[nodiscard]] GameSessionInfo get_session_info() const;
 
     [[nodiscard]] std::vector<int> get_occupied_positions() const;
 
-    [[nodiscard]] const json &get_game_settings() const;
+    [[nodiscard]] std::vector<PlayerInfo> get_players() const;
+
+    //    [[nodiscard]] std::optional<json> &get_game_settings() const; //
+    //    unused, was non-trivial to implement.
+
+    /// Fetches current session information from the DB
+    static drogon_model::cavoke_orm::Sessions get_snapshot(
+        const std::string &session_id);
+
+    /// Builds a session info from a session
+    static GameSessionInfo make_session_info(
+        const drogon_model::cavoke_orm::Sessions &session,
+        const drogon_model::cavoke_orm::Statuses &status,
+        std::vector<PlayerInfo> players);
 
 private:
     std::string id;
-    GameConfig m_game_config;
-    std::string m_invite_code;
-    boost::bimap<std::string, int> m_userid_to_playerid{};
-    json m_game_settings;
+    GameConfig m_game_config{};
 
-private:
-    static std::string generate_invite_code();
+    drogon::orm::DbClientPtr dbClient;
+
+    mutable drogon::orm::Mapper<drogon_model::cavoke_orm::Sessions>
+        default_mp_sessions{dbClient};
+    mutable drogon::orm::Mapper<drogon_model::cavoke_orm::Statuses>
+        default_mp_statuses{dbClient};
+    mutable drogon::orm::Mapper<drogon_model::cavoke_orm::Players>
+        default_mp_players{dbClient};
+
+    drogon_model::cavoke_orm::Sessions get_snapshot() const;
+    drogon_model::cavoke_orm::Statuses get_actual_status() const;
+    void set_status(SessionStatus status);
 };
 
-NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameSession::GameSessionInfo,
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameSessionAccessObject::UserInfo,
+                                   user_id,
+                                   display_name);
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameSessionAccessObject::PlayerInfo,
+                                   user,
+                                   player_id);
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(GameSessionAccessObject::GameSessionInfo,
                                    session_id,
                                    game_id,
-                                   invite_code);
+                                   host_id,
+                                   status,
+                                   players);
 }  // namespace cavoke::server::model
 
 #endif  // CAVOKE_GAME_SESSION_H
diff --git a/server/model/sessions/sessions_storage.cpp b/server/model/sessions/sessions_storage.cpp
index a397e397..1dd12a09 100644
--- a/server/model/sessions/sessions_storage.cpp
+++ b/server/model/sessions/sessions_storage.cpp
@@ -1,5 +1,13 @@
 #include "sessions_storage.h"
 #include <utility>
+#include "sql-models/Globalstates.h"
+#include "sql-models/Rooms.h"
+#include "sql-models/Sessions.h"
+#include "sql-models/Statuses.h"
+
+namespace cavoke::server::model {
+
+using namespace drogon::orm;
 
 /**
  * Creates a session with given game config.
@@ -8,66 +16,174 @@
  *
  * @return session info
  */
-cavoke::server::model::GameSession::GameSessionInfo
-cavoke::server::model::SessionsStorage::create_session(
+GameSessionAccessObject::GameSessionInfo SessionsStorage::create_session(
     const GameConfig &game_config,
-    const std::string &host_user_id) {
+    const std::string &host_user_id,
+    const std::string &room_id) {
+    drogon_model::cavoke_orm::Users user =
+        MAPPER_FOR(drogon_model::cavoke_orm::Users)
+            .findByPrimaryKey(host_user_id);
     // create session
-    auto session = GameSession(game_config);
-    // add host
-    session.add_user(host_user_id);
-    // generate representation for user
-    auto session_info = session.get_session_info();
-    // save session
-    m_sessions.emplace(session_info.session_id, std::move(session));
-    // associate invite code with session
-    // TODO: there are only 1e6 invite codes, something has to be done about
-    // collisions
-    m_invite_codes_to_session_ids[session_info.invite_code] =
-        session_info.session_id;
-    return session_info;
+    auto session = drogon_model::cavoke_orm::Sessions();
+    {
+        session.setId(drogon::utils::getUuid());
+        session.setGameSettingsToNull();
+        session.setGameId(game_config.id);
+    }
+    auto session_status = drogon_model::cavoke_orm::Statuses();
+    {
+        session_status.setStatus(
+            GameSessionAccessObject::SessionStatus::NOT_STARTED);
+        session_status.setSessionId(session.getValueOfId());
+    }
+    auto host_player = drogon_model::cavoke_orm::Players();
+    {
+        // TODO: should we always add host on 0 position?
+        host_player.setPlayerId(0);
+        host_player.setPlayerstate("");
+        host_player.setScoreToNull();
+        host_player.setSessionId(session.getValueOfId());
+        host_player.setUserId(host_user_id);
+    }
+    auto global_state = drogon_model::cavoke_orm::Globalstates();
+    {
+        global_state.setSessionId(session.getValueOfId());
+        global_state.setIsTerminal(false);
+        global_state.setGlobalstateToNull();
+    }
+
+    {
+        auto transaction = drogon::app().getDbClient()->newTransaction();
+        auto mp_sessions = MAPPER_WITH_CLIENT_FOR(
+            drogon_model::cavoke_orm::Sessions, transaction);
+        mp_sessions.insert(session);
+        auto mp_statuses = MAPPER_WITH_CLIENT_FOR(
+            drogon_model::cavoke_orm::Statuses, transaction);
+        mp_statuses.insert(session_status);
+        auto mp_players = MAPPER_WITH_CLIENT_FOR(
+            drogon_model::cavoke_orm::Players, transaction);
+        mp_players.insert(host_player);
+        auto mp_globalstates = MAPPER_WITH_CLIENT_FOR(
+            drogon_model::cavoke_orm::Globalstates, transaction);
+        mp_globalstates.insert(global_state);
+
+        session.setHostId(host_user_id);
+        mp_sessions.update(session);
+
+        if (!room_id.empty()) {
+            auto mp_rooms = MAPPER_WITH_CLIENT_FOR(
+                drogon_model::cavoke_orm::Rooms, transaction);
+            try {
+                mp_rooms.updateBy(
+                    {drogon_model::cavoke_orm::Rooms::Cols::_session_id},
+                    Criteria(drogon_model::cavoke_orm::Rooms::Cols::_id,
+                             CompareOperator::EQ, room_id),
+                    session.getValueOfId());
+            } catch (const UnexpectedRows &) {
+            }
+        }
+    }
+    LOG_DEBUG << "Session created: " << session.getValueOfId();
+    // TODO: cleanup and use GameSessionAccessObject's non-static methods
+    return GameSessionAccessObject::make_session_info(
+        session, session_status,
+        {{GameSessionAccessObject::UserInfo::from_user(user), 0}});
+}
+
+void SessionsStorage::start_session(const std::string &session_id,
+                                    std::optional<json> game_settings) {
+    auto session = get_sessionAO(session_id);
+    auto validation_result = validate_session(session_id, game_settings);
+
+    if (!validation_result.success) {
+        throw validation_error(validation_result.message);
+    }
+    std::string game_id = session.get_session_info().game_id;
+    if (!game_settings.has_value()) {
+        game_settings = m_games_storage->get_game_by_id(game_id)
+                            .value()
+                            .config.default_settings;
+    }
+    // Lock joining
+    session.start(game_settings.value());
+    LOG_DEBUG << "Session started: " << session_id;
+    // Initialize state
+    m_game_state_storage->save_state(
+        session_id,
+        m_game_logic_manager->init_state(game_id, game_settings.value(),
+                                         session.get_occupied_positions()),
+        drogon::app().getDbClient());
 }
 
 /**
- * Joins a session by invite code
+ * Joins a session by id
  *
  * Throws `game_session_error` if errors arise
  *
  * @return session info
  */
-cavoke::server::model::GameSession::GameSessionInfo
-cavoke::server::model::SessionsStorage::join_session(
-    const std::string &invite_code,
-    const std::string &user_id) {
-    // find session by invite
-    try {
-        auto &session =
-            m_sessions[m_invite_codes_to_session_ids.at(invite_code)];
-        // validate invite code
-        if (!session.verify_invite_code(invite_code)) {
-            throw game_session_error("invalid invite code");
-        }
-        // add the user
-        session.add_user(user_id);
-        // generate representation for client
-        return session.get_session_info();
-    } catch (const std::out_of_range &) {
-        throw game_session_error("invite code does not exist: '" + invite_code +
-                                 "'");
+GameSessionAccessObject::GameSessionInfo SessionsStorage::join_session(
+    const std::string &session_id,
+    const std::string &user_id,
+    std::optional<int> player_id) {
+    auto sessionAO = get_sessionAO(session_id);
+    // add the user
+    sessionAO.add_user(user_id, player_id);
+    // generate representation for client
+    return sessionAO.get_session_info();
+}
+
+SessionsStorage::SessionsStorage(
+    std::shared_ptr<GameLogicManager> mGameLogicManager,
+    std::shared_ptr<GamesStorage> mGamesStorage,
+    std::shared_ptr<GameStateStorage> mGameStateStorage)
+    : m_game_logic_manager(std::move(mGameLogicManager)),
+      m_games_storage(std::move(mGamesStorage)),
+      m_game_state_storage(std::move(mGameStateStorage)) {
+}
+cavoke::ValidationResult SessionsStorage::validate_session(
+    const std::string &session_id,
+    std::optional<json> game_settings) {
+    auto session = get_sessionAO(session_id);
+    // FIXME: 2 reads happen not simultaneously
+    std::string game_id = session.get_session_info().game_id;
+    if (!game_settings.has_value()) {
+        game_settings = m_games_storage->get_game_by_id(game_id)
+                            .value()
+                            .config.default_settings;
     }
+
+    return m_game_logic_manager->validate_settings(
+        game_id, game_settings.value(),
+        session.get_occupied_positions());  // FIXME: 2 reads happen not
+                                            // simultaneously
 }
+
 /**
  * Gets a session for given session id
  *
  * Throws `game_session_error` if no such session
  */
-cavoke::server::model::GameSession &
-cavoke::server::model::SessionsStorage::get_session(
-    const std::string &session_id) {
-    try {  // slow?
-        return m_sessions.at(session_id);
+GameSessionAccessObject SessionsStorage::get_sessionAO(
+    const std::string &session_id,
+    drogon::orm::DbClientPtr dbClient) {
+    // INFO: redundancy to check that session actually exists
+    try {
+        auto mp_sessions =
+            MAPPER_WITH_CLIENT_FOR(drogon_model::cavoke_orm::Sessions,
+                                   dbClient);  // TODO: use shared mappers
+        // find session by invite
+        auto session = mp_sessions.findOne(
+            Criteria(drogon_model::cavoke_orm::Sessions::Cols::_id,
+                     CompareOperator::EQ, session_id));
+        return GameSessionAccessObject(
+            session.getValueOfId(),
+            m_games_storage->get_game_by_id(session.getValueOfGameId())->config,
+            dbClient);
     } catch (const std::out_of_range &) {
         throw game_session_error("session does not exist: '" + session_id +
                                  "'");
     }
 }
+
+}  // namespace cavoke::server::model
diff --git a/server/model/sessions/sessions_storage.h b/server/model/sessions/sessions_storage.h
index 660617fe..da0d7250 100644
--- a/server/model/sessions/sessions_storage.h
+++ b/server/model/sessions/sessions_storage.h
@@ -3,26 +3,48 @@
 
 #include <map>
 #include <string>
-#include "model/sessions/game_session.h"
+#include "game_session.h"
+#include "model/logic/game_logic_manager.h"
 
 namespace cavoke::server::model {
 
 class SessionsStorage {
-    // TODO: thread-safety
+    std::shared_ptr<GameLogicManager> m_game_logic_manager;
+    std::shared_ptr<GamesStorage> m_games_storage;
+    std::shared_ptr<GameStateStorage> m_game_state_storage;
 
 public:
-    GameSession::GameSessionInfo create_session(
-        const GameConfig &game_config,
-        const std::string &host_user_id);
-
-    GameSession::GameSessionInfo join_session(const std::string &invite_code,
-                                              const std::string &user_id);
+    SessionsStorage(std::shared_ptr<GameLogicManager> mGameLogicManager,
+                    std::shared_ptr<GamesStorage> mGamesStorage,
+                    std::shared_ptr<GameStateStorage> mGameStateStorage);
 
-    GameSession &get_session(const std::string &session_id);
-
-private:
-    std::map<std::string, GameSession> m_sessions{};
-    std::map<std::string, std::string> m_invite_codes_to_session_ids{};
+    /// Creates session for given user with given game_config
+    GameSessionAccessObject::GameSessionInfo create_session(
+        const GameConfig &game_config,
+        const std::string &host_user_id,
+        const std::string &room_id = "");
+
+    /// Starts session with given settings
+    void start_session(const std::string &session_id,
+                       std::optional<json> game_settings);
+
+    /// Tries to connect given user into a session
+    GameSessionAccessObject::GameSessionInfo join_session(
+        const std::string &invite_code,
+        const std::string &user_id,
+        std::optional<int> player_id = {});
+
+    /// Validates the settings for given session
+    cavoke::ValidationResult validate_session(
+        const std::string &session_id,
+        std::optional<json> game_settings);
+
+    /// Gets an access object for given session
+    GameSessionAccessObject get_sessionAO(
+        const std::string &session_id,
+        drogon::orm::DbClientPtr dbClient = drogon::app().getDbClient());
+
+    friend class GameSessionAccessObject;
 };
 
 }  // namespace cavoke::server::model
diff --git a/server/model/statistics/statistics_manager.cpp b/server/model/statistics/statistics_manager.cpp
new file mode 100644
index 00000000..8d0290fa
--- /dev/null
+++ b/server/model/statistics/statistics_manager.cpp
@@ -0,0 +1,94 @@
+#include "statistics_manager.h"
+#include <utility>
+
+namespace cavoke::server::model {
+
+StatisticsManager::StatisticsManager(
+    std::shared_ptr<SessionsStorage> mSessionStorage,
+    std::shared_ptr<GamesStorage> mGamesStorage)
+    : m_session_storage(std::move(mSessionStorage)),
+      m_games_storage(std::move(mGamesStorage)) {
+}
+
+StatisticsManager::GameStatistics StatisticsManager::get_game_statistics(
+    const std::string &game_id) {
+    return {get_avg_duration(game_id), get_avg_players_cnt(game_id),
+            get_total_time_played(game_id), get_total_games_played(game_id)};
+}
+
+StatisticsManager::UserGameStatistics
+StatisticsManager::get_user_game_statistics(const std::string &user_id,
+                                            const std::string &game_id) {
+    return {game_id, get_user_time_played(user_id, game_id),
+            get_user_games_played(user_id, game_id),
+            get_user_win_rate(user_id, game_id)};
+}
+
+StatisticsManager::UserStatistics StatisticsManager::get_user_statistics(
+    const std::string &user_id) {
+    return {get_user_total_time_played(user_id),
+            get_user_total_games_played(user_id)};
+}
+
+int StatisticsManager::get_avg_duration(const std::string &game_id) {
+    auto db_result = drogon::app().getDbClient()->execSqlSync(
+        "select get_average_session_time_sec($1::varchar) as res;", game_id);
+    return db_result[0]["res"].as<int>();
+}
+
+int StatisticsManager::get_total_time_played(const std::string &game_id) {
+    auto db_result = drogon::app().getDbClient()->execSqlSync(
+        "select get_total_time_sec($1::varchar) as res;", game_id);
+    return db_result[0]["res"].as<int>();
+}
+
+int StatisticsManager::get_total_games_played(const std::string &game_id) {
+    auto db_result = drogon::app().getDbClient()->execSqlSync(
+        "select get_sessions_num($1::varchar) as res;", game_id);
+    return db_result[0]["res"].as<int>();
+}
+
+int StatisticsManager::get_avg_players_cnt(const std::string &game_id) {
+    auto db_result = drogon::app().getDbClient()->execSqlSync(
+        "select get_average_players_num($1::varchar) as res;", game_id);
+    return db_result[0]["res"].as<int>();
+}
+
+int StatisticsManager::get_user_total_time_played(const std::string &user_id) {
+    auto db_result = drogon::app().getDbClient()->execSqlSync(
+        "select get_cavoke_time_sec_for_user($1::varchar) as res;", user_id);
+    return db_result[0]["res"].as<int>();
+}
+
+int StatisticsManager::get_user_total_games_played(const std::string &user_id) {
+    auto db_result = drogon::app().getDbClient()->execSqlSync(
+        "select get_cavoke_sessions_num_for_user($1::varchar) as res;",
+        user_id);
+    return db_result[0]["res"].as<int>();
+}
+
+double StatisticsManager::get_user_win_rate(const std::string &user_id,
+                                            const std::string &game_id) {
+    auto db_result = drogon::app().getDbClient()->execSqlSync(
+        "select get_win_rate($1::varchar, $2::varchar) as res;", game_id,
+        user_id);
+    return db_result[0]["res"].as<double>();
+}
+
+int StatisticsManager::get_user_games_played(const std::string &user_id,
+                                             const std::string &game_id) {
+    auto db_result = drogon::app().getDbClient()->execSqlSync(
+        "select get_sessions_num_for_user($1::varchar, $2::varchar) as res;",
+        game_id, user_id);
+    return db_result[0]["res"].as<int>();
+}
+
+int StatisticsManager::get_user_time_played(const std::string &user_id,
+                                            const std::string &game_id) {
+    auto db_result = drogon::app().getDbClient()->execSqlSync(
+        "select get_total_time_sec_for_user($1::varchar, $2::varchar) as res;",
+        game_id, user_id);
+    return db_result[0]["res"].as<int>();
+}
+
+}  // namespace cavoke::server::model
diff --git a/server/model/statistics/statistics_manager.h b/server/model/statistics/statistics_manager.h
new file mode 100644
index 00000000..9a075b7b
--- /dev/null
+++ b/server/model/statistics/statistics_manager.h
@@ -0,0 +1,74 @@
+#ifndef CAVOKE_STATISTICS_MANAGER_H
+#define CAVOKE_STATISTICS_MANAGER_H
+
+#include <memory>
+#include "model/sessions/sessions_storage.h"
+
+namespace cavoke::server::model {
+
+class StatisticsManager {
+    std::shared_ptr<SessionsStorage> m_session_storage;
+    std::shared_ptr<GamesStorage> m_games_storage;
+
+public:
+    explicit StatisticsManager(std::shared_ptr<SessionsStorage> mSessionStorage,
+                               std::shared_ptr<GamesStorage> mGamesStorage);
+
+    struct GameStatistics {
+        int average_duration_sec;
+        int average_players_count;
+        int total_time_played_sec;
+        int total_games_played;
+    };
+
+    struct UserGameStatistics {
+        std::string game_id;
+        int time_played_sec;
+        int games_played;
+        double win_rate;
+    };
+
+    struct UserStatistics {
+        int total_time_played_sec;
+        int total_games_played;
+    };
+
+    GameStatistics get_game_statistics(const std::string &game_id);
+    UserGameStatistics get_user_game_statistics(const std::string &user_id,
+                                                const std::string &game_id);
+    StatisticsManager::UserStatistics get_user_statistics(
+        const std::string &user_id);
+
+private:
+    int get_avg_duration(const std::string &game_id);
+    int get_avg_players_cnt(const std::string &game_id);
+    int get_total_time_played(const std::string &game_id);
+    int get_total_games_played(const std::string &game_id);
+    int get_user_total_time_played(const std::string &user_id);
+    int get_user_total_games_played(const std::string &user_id);
+    double get_user_win_rate(const std::string &user_id,
+                             const std::string &game_id);
+    int get_user_games_played(const std::string &user_id,
+                              const std::string &game_id);
+    int get_user_time_played(const std::string &user_id,
+                             const std::string &game_id);
+};
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(StatisticsManager::GameStatistics,
+                                   average_duration_sec,
+                                   average_players_count,
+                                   total_time_played_sec,
+                                   total_games_played);
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(StatisticsManager::UserGameStatistics,
+                                   time_played_sec,
+                                   games_played,
+                                   win_rate);
+
+NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(StatisticsManager::UserStatistics,
+                                   total_time_played_sec,
+                                   total_games_played);
+
+}  // namespace cavoke::server::model
+
+#endif  // CAVOKE_STATISTICS_MANAGER_H
diff --git a/server/sql-models/Gamesubmissions.cc b/server/sql-models/Gamesubmissions.cc
new file mode 100644
index 00000000..762e2e08
--- /dev/null
+++ b/server/sql-models/Gamesubmissions.cc
@@ -0,0 +1,1144 @@
+/**
+ *
+ *  Gamesubmissions.cc
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#include "Gamesubmissions.h"
+#include <drogon/utils/Utilities.h>
+#include <string>
+
+using namespace drogon;
+using namespace drogon::orm;
+using namespace drogon_model::cavoke;
+
+const std::string Gamesubmissions::Cols::_id = "id";
+const std::string Gamesubmissions::Cols::_game_id = "game_id";
+const std::string Gamesubmissions::Cols::_package_type = "package_type";
+const std::string Gamesubmissions::Cols::_git_repo = "git_repo";
+const std::string Gamesubmissions::Cols::_review_status = "review_status";
+const std::string Gamesubmissions::Cols::_submitted_at = "submitted_at";
+const std::string Gamesubmissions::Cols::_display_name = "display_name";
+const std::string Gamesubmissions::primaryKeyName = "id";
+const bool Gamesubmissions::hasPrimaryKey = true;
+const std::string Gamesubmissions::tableName = "gamesubmissions";
+
+const std::vector<typename Gamesubmissions::MetaData>
+    Gamesubmissions::metaData_ = {
+        {"id", "std::string", "uuid", 0, 0, 1, 1},
+        {"game_id", "std::string", "character varying", 0, 0, 0, 0},
+        {"package_type", "std::string", "character varying", 0, 0, 0, 0},
+        {"git_repo", "std::string", "character varying", 0, 0, 0, 0},
+        {"review_status", "int32_t", "integer", 4, 0, 0, 0},
+        {"submitted_at", "::trantor::Date", "timestamp without time zone", 0, 0,
+         0, 0},
+        {"display_name", "std::string", "character varying", 0, 0, 0, 0}};
+const std::string &Gamesubmissions::getColumnName(size_t index) noexcept(
+    false) {
+    assert(index < metaData_.size());
+    return metaData_[index].colName_;
+}
+Gamesubmissions::Gamesubmissions(const Row &r,
+                                 const ssize_t indexOffset) noexcept {
+    if (indexOffset < 0) {
+        if (!r["id"].isNull()) {
+            id_ = std::make_shared<std::string>(r["id"].as<std::string>());
+        }
+        if (!r["game_id"].isNull()) {
+            gameId_ =
+                std::make_shared<std::string>(r["game_id"].as<std::string>());
+        }
+        if (!r["package_type"].isNull()) {
+            packageType_ = std::make_shared<std::string>(
+                r["package_type"].as<std::string>());
+        }
+        if (!r["git_repo"].isNull()) {
+            gitRepo_ =
+                std::make_shared<std::string>(r["git_repo"].as<std::string>());
+        }
+        if (!r["review_status"].isNull()) {
+            reviewStatus_ =
+                std::make_shared<int32_t>(r["review_status"].as<int32_t>());
+        }
+        if (!r["submitted_at"].isNull()) {
+            auto timeStr = r["submitted_at"].as<std::string>();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                submittedAt_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+        if (!r["display_name"].isNull()) {
+            displayName_ = std::make_shared<std::string>(
+                r["display_name"].as<std::string>());
+        }
+    } else {
+        size_t offset = (size_t)indexOffset;
+        if (offset + 7 > r.size()) {
+            LOG_FATAL << "Invalid SQL result for this model";
+            return;
+        }
+        size_t index;
+        index = offset + 0;
+        if (!r[index].isNull()) {
+            id_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 1;
+        if (!r[index].isNull()) {
+            gameId_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 2;
+        if (!r[index].isNull()) {
+            packageType_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 3;
+        if (!r[index].isNull()) {
+            gitRepo_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 4;
+        if (!r[index].isNull()) {
+            reviewStatus_ = std::make_shared<int32_t>(r[index].as<int32_t>());
+        }
+        index = offset + 5;
+        if (!r[index].isNull()) {
+            auto timeStr = r[index].as<std::string>();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                submittedAt_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+        index = offset + 6;
+        if (!r[index].isNull()) {
+            displayName_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+    }
+}
+
+Gamesubmissions::Gamesubmissions(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 7) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        dirtyFlag_[0] = true;
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            id_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            gameId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            packageType_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[2]].asString());
+        }
+    }
+    if (!pMasqueradingVector[3].empty() &&
+        pJson.isMember(pMasqueradingVector[3])) {
+        dirtyFlag_[3] = true;
+        if (!pJson[pMasqueradingVector[3]].isNull()) {
+            gitRepo_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[3]].asString());
+        }
+    }
+    if (!pMasqueradingVector[4].empty() &&
+        pJson.isMember(pMasqueradingVector[4])) {
+        dirtyFlag_[4] = true;
+        if (!pJson[pMasqueradingVector[4]].isNull()) {
+            reviewStatus_ = std::make_shared<int32_t>(
+                (int32_t)pJson[pMasqueradingVector[4]].asInt64());
+        }
+    }
+    if (!pMasqueradingVector[5].empty() &&
+        pJson.isMember(pMasqueradingVector[5])) {
+        dirtyFlag_[5] = true;
+        if (!pJson[pMasqueradingVector[5]].isNull()) {
+            auto timeStr = pJson[pMasqueradingVector[5]].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                submittedAt_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+    if (!pMasqueradingVector[6].empty() &&
+        pJson.isMember(pMasqueradingVector[6])) {
+        dirtyFlag_[6] = true;
+        if (!pJson[pMasqueradingVector[6]].isNull()) {
+            displayName_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[6]].asString());
+        }
+    }
+}
+
+Gamesubmissions::Gamesubmissions(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("id")) {
+        dirtyFlag_[0] = true;
+        if (!pJson["id"].isNull()) {
+            id_ = std::make_shared<std::string>(pJson["id"].asString());
+        }
+    }
+    if (pJson.isMember("game_id")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["game_id"].isNull()) {
+            gameId_ =
+                std::make_shared<std::string>(pJson["game_id"].asString());
+        }
+    }
+    if (pJson.isMember("package_type")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["package_type"].isNull()) {
+            packageType_ =
+                std::make_shared<std::string>(pJson["package_type"].asString());
+        }
+    }
+    if (pJson.isMember("git_repo")) {
+        dirtyFlag_[3] = true;
+        if (!pJson["git_repo"].isNull()) {
+            gitRepo_ =
+                std::make_shared<std::string>(pJson["git_repo"].asString());
+        }
+    }
+    if (pJson.isMember("review_status")) {
+        dirtyFlag_[4] = true;
+        if (!pJson["review_status"].isNull()) {
+            reviewStatus_ = std::make_shared<int32_t>(
+                (int32_t)pJson["review_status"].asInt64());
+        }
+    }
+    if (pJson.isMember("submitted_at")) {
+        dirtyFlag_[5] = true;
+        if (!pJson["submitted_at"].isNull()) {
+            auto timeStr = pJson["submitted_at"].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                submittedAt_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+    if (pJson.isMember("display_name")) {
+        dirtyFlag_[6] = true;
+        if (!pJson["display_name"].isNull()) {
+            displayName_ =
+                std::make_shared<std::string>(pJson["display_name"].asString());
+        }
+    }
+}
+
+void Gamesubmissions::updateByMasqueradedJson(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 7) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            id_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            gameId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            packageType_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[2]].asString());
+        }
+    }
+    if (!pMasqueradingVector[3].empty() &&
+        pJson.isMember(pMasqueradingVector[3])) {
+        dirtyFlag_[3] = true;
+        if (!pJson[pMasqueradingVector[3]].isNull()) {
+            gitRepo_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[3]].asString());
+        }
+    }
+    if (!pMasqueradingVector[4].empty() &&
+        pJson.isMember(pMasqueradingVector[4])) {
+        dirtyFlag_[4] = true;
+        if (!pJson[pMasqueradingVector[4]].isNull()) {
+            reviewStatus_ = std::make_shared<int32_t>(
+                (int32_t)pJson[pMasqueradingVector[4]].asInt64());
+        }
+    }
+    if (!pMasqueradingVector[5].empty() &&
+        pJson.isMember(pMasqueradingVector[5])) {
+        dirtyFlag_[5] = true;
+        if (!pJson[pMasqueradingVector[5]].isNull()) {
+            auto timeStr = pJson[pMasqueradingVector[5]].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                submittedAt_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+    if (!pMasqueradingVector[6].empty() &&
+        pJson.isMember(pMasqueradingVector[6])) {
+        dirtyFlag_[6] = true;
+        if (!pJson[pMasqueradingVector[6]].isNull()) {
+            displayName_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[6]].asString());
+        }
+    }
+}
+
+void Gamesubmissions::updateByJson(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("id")) {
+        if (!pJson["id"].isNull()) {
+            id_ = std::make_shared<std::string>(pJson["id"].asString());
+        }
+    }
+    if (pJson.isMember("game_id")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["game_id"].isNull()) {
+            gameId_ =
+                std::make_shared<std::string>(pJson["game_id"].asString());
+        }
+    }
+    if (pJson.isMember("package_type")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["package_type"].isNull()) {
+            packageType_ =
+                std::make_shared<std::string>(pJson["package_type"].asString());
+        }
+    }
+    if (pJson.isMember("git_repo")) {
+        dirtyFlag_[3] = true;
+        if (!pJson["git_repo"].isNull()) {
+            gitRepo_ =
+                std::make_shared<std::string>(pJson["git_repo"].asString());
+        }
+    }
+    if (pJson.isMember("review_status")) {
+        dirtyFlag_[4] = true;
+        if (!pJson["review_status"].isNull()) {
+            reviewStatus_ = std::make_shared<int32_t>(
+                (int32_t)pJson["review_status"].asInt64());
+        }
+    }
+    if (pJson.isMember("submitted_at")) {
+        dirtyFlag_[5] = true;
+        if (!pJson["submitted_at"].isNull()) {
+            auto timeStr = pJson["submitted_at"].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                submittedAt_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+    if (pJson.isMember("display_name")) {
+        dirtyFlag_[6] = true;
+        if (!pJson["display_name"].isNull()) {
+            displayName_ =
+                std::make_shared<std::string>(pJson["display_name"].asString());
+        }
+    }
+}
+
+const std::string &Gamesubmissions::getValueOfId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (id_)
+        return *id_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Gamesubmissions::getId() const noexcept {
+    return id_;
+}
+void Gamesubmissions::setId(const std::string &pId) noexcept {
+    id_ = std::make_shared<std::string>(pId);
+    dirtyFlag_[0] = true;
+}
+void Gamesubmissions::setId(std::string &&pId) noexcept {
+    id_ = std::make_shared<std::string>(std::move(pId));
+    dirtyFlag_[0] = true;
+}
+const typename Gamesubmissions::PrimaryKeyType &Gamesubmissions::getPrimaryKey()
+    const {
+    assert(id_);
+    return *id_;
+}
+
+const std::string &Gamesubmissions::getValueOfGameId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (gameId_)
+        return *gameId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Gamesubmissions::getGameId()
+    const noexcept {
+    return gameId_;
+}
+void Gamesubmissions::setGameId(const std::string &pGameId) noexcept {
+    gameId_ = std::make_shared<std::string>(pGameId);
+    dirtyFlag_[1] = true;
+}
+void Gamesubmissions::setGameId(std::string &&pGameId) noexcept {
+    gameId_ = std::make_shared<std::string>(std::move(pGameId));
+    dirtyFlag_[1] = true;
+}
+void Gamesubmissions::setGameIdToNull() noexcept {
+    gameId_.reset();
+    dirtyFlag_[1] = true;
+}
+
+const std::string &Gamesubmissions::getValueOfPackageType() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (packageType_)
+        return *packageType_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Gamesubmissions::getPackageType()
+    const noexcept {
+    return packageType_;
+}
+void Gamesubmissions::setPackageType(const std::string &pPackageType) noexcept {
+    packageType_ = std::make_shared<std::string>(pPackageType);
+    dirtyFlag_[2] = true;
+}
+void Gamesubmissions::setPackageType(std::string &&pPackageType) noexcept {
+    packageType_ = std::make_shared<std::string>(std::move(pPackageType));
+    dirtyFlag_[2] = true;
+}
+void Gamesubmissions::setPackageTypeToNull() noexcept {
+    packageType_.reset();
+    dirtyFlag_[2] = true;
+}
+
+const std::string &Gamesubmissions::getValueOfGitRepo() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (gitRepo_)
+        return *gitRepo_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Gamesubmissions::getGitRepo()
+    const noexcept {
+    return gitRepo_;
+}
+void Gamesubmissions::setGitRepo(const std::string &pGitRepo) noexcept {
+    gitRepo_ = std::make_shared<std::string>(pGitRepo);
+    dirtyFlag_[3] = true;
+}
+void Gamesubmissions::setGitRepo(std::string &&pGitRepo) noexcept {
+    gitRepo_ = std::make_shared<std::string>(std::move(pGitRepo));
+    dirtyFlag_[3] = true;
+}
+void Gamesubmissions::setGitRepoToNull() noexcept {
+    gitRepo_.reset();
+    dirtyFlag_[3] = true;
+}
+
+const int32_t &Gamesubmissions::getValueOfReviewStatus() const noexcept {
+    const static int32_t defaultValue = int32_t();
+    if (reviewStatus_)
+        return *reviewStatus_;
+    return defaultValue;
+}
+const std::shared_ptr<int32_t> &Gamesubmissions::getReviewStatus()
+    const noexcept {
+    return reviewStatus_;
+}
+void Gamesubmissions::setReviewStatus(const int32_t &pReviewStatus) noexcept {
+    reviewStatus_ = std::make_shared<int32_t>(pReviewStatus);
+    dirtyFlag_[4] = true;
+}
+void Gamesubmissions::setReviewStatusToNull() noexcept {
+    reviewStatus_.reset();
+    dirtyFlag_[4] = true;
+}
+
+const ::trantor::Date &Gamesubmissions::getValueOfSubmittedAt() const noexcept {
+    const static ::trantor::Date defaultValue = ::trantor::Date();
+    if (submittedAt_)
+        return *submittedAt_;
+    return defaultValue;
+}
+const std::shared_ptr<::trantor::Date> &Gamesubmissions::getSubmittedAt()
+    const noexcept {
+    return submittedAt_;
+}
+void Gamesubmissions::setSubmittedAt(
+    const ::trantor::Date &pSubmittedAt) noexcept {
+    submittedAt_ = std::make_shared<::trantor::Date>(pSubmittedAt);
+    dirtyFlag_[5] = true;
+}
+void Gamesubmissions::setSubmittedAtToNull() noexcept {
+    submittedAt_.reset();
+    dirtyFlag_[5] = true;
+}
+
+const std::string &Gamesubmissions::getValueOfDisplayName() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (displayName_)
+        return *displayName_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Gamesubmissions::getDisplayName()
+    const noexcept {
+    return displayName_;
+}
+void Gamesubmissions::setDisplayName(const std::string &pDisplayName) noexcept {
+    displayName_ = std::make_shared<std::string>(pDisplayName);
+    dirtyFlag_[6] = true;
+}
+void Gamesubmissions::setDisplayName(std::string &&pDisplayName) noexcept {
+    displayName_ = std::make_shared<std::string>(std::move(pDisplayName));
+    dirtyFlag_[6] = true;
+}
+void Gamesubmissions::setDisplayNameToNull() noexcept {
+    displayName_.reset();
+    dirtyFlag_[6] = true;
+}
+
+void Gamesubmissions::updateId(const uint64_t id) {
+}
+
+const std::vector<std::string> &Gamesubmissions::insertColumns() noexcept {
+    static const std::vector<std::string> inCols = {
+        "id",          "game_id",       "package_type",
+        "git_repo",    "review_status", "submitted_at",
+        "display_name"};
+    return inCols;
+}
+
+void Gamesubmissions::outputArgs(
+    drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getId()) {
+            binder << getValueOfId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getGameId()) {
+            binder << getValueOfGameId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getPackageType()) {
+            binder << getValueOfPackageType();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[3]) {
+        if (getGitRepo()) {
+            binder << getValueOfGitRepo();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[4]) {
+        if (getReviewStatus()) {
+            binder << getValueOfReviewStatus();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[5]) {
+        if (getSubmittedAt()) {
+            binder << getValueOfSubmittedAt();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[6]) {
+        if (getDisplayName()) {
+            binder << getValueOfDisplayName();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+
+const std::vector<std::string> Gamesubmissions::updateColumns() const {
+    std::vector<std::string> ret;
+    if (dirtyFlag_[0]) {
+        ret.push_back(getColumnName(0));
+    }
+    if (dirtyFlag_[1]) {
+        ret.push_back(getColumnName(1));
+    }
+    if (dirtyFlag_[2]) {
+        ret.push_back(getColumnName(2));
+    }
+    if (dirtyFlag_[3]) {
+        ret.push_back(getColumnName(3));
+    }
+    if (dirtyFlag_[4]) {
+        ret.push_back(getColumnName(4));
+    }
+    if (dirtyFlag_[5]) {
+        ret.push_back(getColumnName(5));
+    }
+    if (dirtyFlag_[6]) {
+        ret.push_back(getColumnName(6));
+    }
+    return ret;
+}
+
+void Gamesubmissions::updateArgs(
+    drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getId()) {
+            binder << getValueOfId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getGameId()) {
+            binder << getValueOfGameId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getPackageType()) {
+            binder << getValueOfPackageType();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[3]) {
+        if (getGitRepo()) {
+            binder << getValueOfGitRepo();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[4]) {
+        if (getReviewStatus()) {
+            binder << getValueOfReviewStatus();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[5]) {
+        if (getSubmittedAt()) {
+            binder << getValueOfSubmittedAt();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[6]) {
+        if (getDisplayName()) {
+            binder << getValueOfDisplayName();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+Json::Value Gamesubmissions::toJson() const {
+    Json::Value ret;
+    if (getId()) {
+        ret["id"] = getValueOfId();
+    } else {
+        ret["id"] = Json::Value();
+    }
+    if (getGameId()) {
+        ret["game_id"] = getValueOfGameId();
+    } else {
+        ret["game_id"] = Json::Value();
+    }
+    if (getPackageType()) {
+        ret["package_type"] = getValueOfPackageType();
+    } else {
+        ret["package_type"] = Json::Value();
+    }
+    if (getGitRepo()) {
+        ret["git_repo"] = getValueOfGitRepo();
+    } else {
+        ret["git_repo"] = Json::Value();
+    }
+    if (getReviewStatus()) {
+        ret["review_status"] = getValueOfReviewStatus();
+    } else {
+        ret["review_status"] = Json::Value();
+    }
+    if (getSubmittedAt()) {
+        ret["submitted_at"] = getSubmittedAt()->toDbStringLocal();
+    } else {
+        ret["submitted_at"] = Json::Value();
+    }
+    if (getDisplayName()) {
+        ret["display_name"] = getValueOfDisplayName();
+    } else {
+        ret["display_name"] = Json::Value();
+    }
+    return ret;
+}
+
+Json::Value Gamesubmissions::toMasqueradedJson(
+    const std::vector<std::string> &pMasqueradingVector) const {
+    Json::Value ret;
+    if (pMasqueradingVector.size() == 7) {
+        if (!pMasqueradingVector[0].empty()) {
+            if (getId()) {
+                ret[pMasqueradingVector[0]] = getValueOfId();
+            } else {
+                ret[pMasqueradingVector[0]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (getGameId()) {
+                ret[pMasqueradingVector[1]] = getValueOfGameId();
+            } else {
+                ret[pMasqueradingVector[1]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (getPackageType()) {
+                ret[pMasqueradingVector[2]] = getValueOfPackageType();
+            } else {
+                ret[pMasqueradingVector[2]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[3].empty()) {
+            if (getGitRepo()) {
+                ret[pMasqueradingVector[3]] = getValueOfGitRepo();
+            } else {
+                ret[pMasqueradingVector[3]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[4].empty()) {
+            if (getReviewStatus()) {
+                ret[pMasqueradingVector[4]] = getValueOfReviewStatus();
+            } else {
+                ret[pMasqueradingVector[4]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[5].empty()) {
+            if (getSubmittedAt()) {
+                ret[pMasqueradingVector[5]] =
+                    getSubmittedAt()->toDbStringLocal();
+            } else {
+                ret[pMasqueradingVector[5]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[6].empty()) {
+            if (getDisplayName()) {
+                ret[pMasqueradingVector[6]] = getValueOfDisplayName();
+            } else {
+                ret[pMasqueradingVector[6]] = Json::Value();
+            }
+        }
+        return ret;
+    }
+    LOG_ERROR << "Masquerade failed";
+    if (getId()) {
+        ret["id"] = getValueOfId();
+    } else {
+        ret["id"] = Json::Value();
+    }
+    if (getGameId()) {
+        ret["game_id"] = getValueOfGameId();
+    } else {
+        ret["game_id"] = Json::Value();
+    }
+    if (getPackageType()) {
+        ret["package_type"] = getValueOfPackageType();
+    } else {
+        ret["package_type"] = Json::Value();
+    }
+    if (getGitRepo()) {
+        ret["git_repo"] = getValueOfGitRepo();
+    } else {
+        ret["git_repo"] = Json::Value();
+    }
+    if (getReviewStatus()) {
+        ret["review_status"] = getValueOfReviewStatus();
+    } else {
+        ret["review_status"] = Json::Value();
+    }
+    if (getSubmittedAt()) {
+        ret["submitted_at"] = getSubmittedAt()->toDbStringLocal();
+    } else {
+        ret["submitted_at"] = Json::Value();
+    }
+    if (getDisplayName()) {
+        ret["display_name"] = getValueOfDisplayName();
+    } else {
+        ret["display_name"] = Json::Value();
+    }
+    return ret;
+}
+
+bool Gamesubmissions::validateJsonForCreation(const Json::Value &pJson,
+                                              std::string &err) {
+    if (pJson.isMember("id")) {
+        if (!validJsonOfField(0, "id", pJson["id"], err, true))
+            return false;
+    }
+    if (pJson.isMember("game_id")) {
+        if (!validJsonOfField(1, "game_id", pJson["game_id"], err, true))
+            return false;
+    }
+    if (pJson.isMember("package_type")) {
+        if (!validJsonOfField(2, "package_type", pJson["package_type"], err,
+                              true))
+            return false;
+    }
+    if (pJson.isMember("git_repo")) {
+        if (!validJsonOfField(3, "git_repo", pJson["git_repo"], err, true))
+            return false;
+    }
+    if (pJson.isMember("review_status")) {
+        if (!validJsonOfField(4, "review_status", pJson["review_status"], err,
+                              true))
+            return false;
+    }
+    if (pJson.isMember("submitted_at")) {
+        if (!validJsonOfField(5, "submitted_at", pJson["submitted_at"], err,
+                              true))
+            return false;
+    }
+    if (pJson.isMember("display_name")) {
+        if (!validJsonOfField(6, "display_name", pJson["display_name"], err,
+                              true))
+            return false;
+    }
+    return true;
+}
+bool Gamesubmissions::validateMasqueradedJsonForCreation(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 7) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty()) {
+            if (pJson.isMember(pMasqueradingVector[0])) {
+                if (!validJsonOfField(0, pMasqueradingVector[0],
+                                      pJson[pMasqueradingVector[0]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (pJson.isMember(pMasqueradingVector[1])) {
+                if (!validJsonOfField(1, pMasqueradingVector[1],
+                                      pJson[pMasqueradingVector[1]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (pJson.isMember(pMasqueradingVector[2])) {
+                if (!validJsonOfField(2, pMasqueradingVector[2],
+                                      pJson[pMasqueradingVector[2]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[3].empty()) {
+            if (pJson.isMember(pMasqueradingVector[3])) {
+                if (!validJsonOfField(3, pMasqueradingVector[3],
+                                      pJson[pMasqueradingVector[3]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[4].empty()) {
+            if (pJson.isMember(pMasqueradingVector[4])) {
+                if (!validJsonOfField(4, pMasqueradingVector[4],
+                                      pJson[pMasqueradingVector[4]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[5].empty()) {
+            if (pJson.isMember(pMasqueradingVector[5])) {
+                if (!validJsonOfField(5, pMasqueradingVector[5],
+                                      pJson[pMasqueradingVector[5]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[6].empty()) {
+            if (pJson.isMember(pMasqueradingVector[6])) {
+                if (!validJsonOfField(6, pMasqueradingVector[6],
+                                      pJson[pMasqueradingVector[6]], err, true))
+                    return false;
+            }
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Gamesubmissions::validateJsonForUpdate(const Json::Value &pJson,
+                                            std::string &err) {
+    if (pJson.isMember("id")) {
+        if (!validJsonOfField(0, "id", pJson["id"], err, false))
+            return false;
+    } else {
+        err =
+            "The value of primary key must be set in the json object for "
+            "update";
+        return false;
+    }
+    if (pJson.isMember("game_id")) {
+        if (!validJsonOfField(1, "game_id", pJson["game_id"], err, false))
+            return false;
+    }
+    if (pJson.isMember("package_type")) {
+        if (!validJsonOfField(2, "package_type", pJson["package_type"], err,
+                              false))
+            return false;
+    }
+    if (pJson.isMember("git_repo")) {
+        if (!validJsonOfField(3, "git_repo", pJson["git_repo"], err, false))
+            return false;
+    }
+    if (pJson.isMember("review_status")) {
+        if (!validJsonOfField(4, "review_status", pJson["review_status"], err,
+                              false))
+            return false;
+    }
+    if (pJson.isMember("submitted_at")) {
+        if (!validJsonOfField(5, "submitted_at", pJson["submitted_at"], err,
+                              false))
+            return false;
+    }
+    if (pJson.isMember("display_name")) {
+        if (!validJsonOfField(6, "display_name", pJson["display_name"], err,
+                              false))
+            return false;
+    }
+    return true;
+}
+bool Gamesubmissions::validateMasqueradedJsonForUpdate(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 7) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty() &&
+            pJson.isMember(pMasqueradingVector[0])) {
+            if (!validJsonOfField(0, pMasqueradingVector[0],
+                                  pJson[pMasqueradingVector[0]], err, false))
+                return false;
+        } else {
+            err =
+                "The value of primary key must be set in the json object for "
+                "update";
+            return false;
+        }
+        if (!pMasqueradingVector[1].empty() &&
+            pJson.isMember(pMasqueradingVector[1])) {
+            if (!validJsonOfField(1, pMasqueradingVector[1],
+                                  pJson[pMasqueradingVector[1]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[2].empty() &&
+            pJson.isMember(pMasqueradingVector[2])) {
+            if (!validJsonOfField(2, pMasqueradingVector[2],
+                                  pJson[pMasqueradingVector[2]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[3].empty() &&
+            pJson.isMember(pMasqueradingVector[3])) {
+            if (!validJsonOfField(3, pMasqueradingVector[3],
+                                  pJson[pMasqueradingVector[3]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[4].empty() &&
+            pJson.isMember(pMasqueradingVector[4])) {
+            if (!validJsonOfField(4, pMasqueradingVector[4],
+                                  pJson[pMasqueradingVector[4]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[5].empty() &&
+            pJson.isMember(pMasqueradingVector[5])) {
+            if (!validJsonOfField(5, pMasqueradingVector[5],
+                                  pJson[pMasqueradingVector[5]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[6].empty() &&
+            pJson.isMember(pMasqueradingVector[6])) {
+            if (!validJsonOfField(6, pMasqueradingVector[6],
+                                  pJson[pMasqueradingVector[6]], err, false))
+                return false;
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Gamesubmissions::validJsonOfField(size_t index,
+                                       const std::string &fieldName,
+                                       const Json::Value &pJson,
+                                       std::string &err,
+                                       bool isForCreation) {
+    switch (index) {
+        case 0:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 1:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 2:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 3:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 4:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isInt()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 5:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 6:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        default:
+            err = "Internal error in the server";
+            return false;
+            break;
+    }
+    return true;
+}
diff --git a/server/sql-models/Gamesubmissions.h b/server/sql-models/Gamesubmissions.h
new file mode 100644
index 00000000..82a20312
--- /dev/null
+++ b/server/sql-models/Gamesubmissions.h
@@ -0,0 +1,328 @@
+/**
+ *
+ *  Gamesubmissions.h
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#pragma once
+#include <drogon/orm/Field.h>
+#include <drogon/orm/Mapper.h>
+#include <drogon/orm/Result.h>
+#include <drogon/orm/Row.h>
+#include <drogon/orm/SqlBinder.h>
+#ifdef __cpp_impl_coroutine
+#include <drogon/orm/CoroMapper.h>
+#endif
+#include <json/json.h>
+#include <stdint.h>
+#include <trantor/utils/Date.h>
+#include <trantor/utils/Logger.h>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace drogon {
+namespace orm {
+class DbClient;
+using DbClientPtr = std::shared_ptr<DbClient>;
+}  // namespace orm
+}  // namespace drogon
+namespace drogon_model {
+namespace cavoke {
+
+class Gamesubmissions {
+public:
+    struct Cols {
+        static const std::string _id;
+        static const std::string _game_id;
+        static const std::string _package_type;
+        static const std::string _git_repo;
+        static const std::string _review_status;
+        static const std::string _submitted_at;
+        static const std::string _display_name;
+    };
+
+    const static int primaryKeyNumber;
+    const static std::string tableName;
+    const static bool hasPrimaryKey;
+    const static std::string primaryKeyName;
+    using PrimaryKeyType = std::string;
+    const PrimaryKeyType &getPrimaryKey() const;
+
+    /**
+     * @brief constructor
+     * @param r One row of records in the SQL query result.
+     * @param indexOffset Set the offset to -1 to access all columns by column
+     * names, otherwise access all columns by offsets.
+     * @note If the SQL is not a style of 'select * from table_name ...' (select
+     * all columns by an asterisk), please set the offset to -1.
+     */
+    explicit Gamesubmissions(const drogon::orm::Row &r,
+                             const ssize_t indexOffset = 0) noexcept;
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     */
+    explicit Gamesubmissions(const Json::Value &pJson) noexcept(false);
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     * @param pMasqueradingVector The aliases of table columns.
+     */
+    Gamesubmissions(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+
+    Gamesubmissions() = default;
+
+    void updateByJson(const Json::Value &pJson) noexcept(false);
+    void updateByMasqueradedJson(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+    static bool validateJsonForCreation(const Json::Value &pJson,
+                                        std::string &err);
+    static bool validateMasqueradedJsonForCreation(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validateJsonForUpdate(const Json::Value &pJson,
+                                      std::string &err);
+    static bool validateMasqueradedJsonForUpdate(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validJsonOfField(size_t index,
+                                 const std::string &fieldName,
+                                 const Json::Value &pJson,
+                                 std::string &err,
+                                 bool isForCreation);
+
+    /**  For column id  */
+    /// Get the value of the column id, returns the default value if the column
+    /// is null
+    const std::string &getValueOfId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getId() const noexcept;
+    /// Set the value of the column id
+    void setId(const std::string &pId) noexcept;
+    void setId(std::string &&pId) noexcept;
+
+    /**  For column game_id  */
+    /// Get the value of the column game_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfGameId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getGameId() const noexcept;
+    /// Set the value of the column game_id
+    void setGameId(const std::string &pGameId) noexcept;
+    void setGameId(std::string &&pGameId) noexcept;
+    void setGameIdToNull() noexcept;
+
+    /**  For column package_type  */
+    /// Get the value of the column package_type, returns the default value if
+    /// the column is null
+    const std::string &getValueOfPackageType() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getPackageType() const noexcept;
+    /// Set the value of the column package_type
+    void setPackageType(const std::string &pPackageType) noexcept;
+    void setPackageType(std::string &&pPackageType) noexcept;
+    void setPackageTypeToNull() noexcept;
+
+    /**  For column git_repo  */
+    /// Get the value of the column git_repo, returns the default value if the
+    /// column is null
+    const std::string &getValueOfGitRepo() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getGitRepo() const noexcept;
+    /// Set the value of the column git_repo
+    void setGitRepo(const std::string &pGitRepo) noexcept;
+    void setGitRepo(std::string &&pGitRepo) noexcept;
+    void setGitRepoToNull() noexcept;
+
+    /**  For column review_status  */
+    /// Get the value of the column review_status, returns the default value if
+    /// the column is null
+    const int32_t &getValueOfReviewStatus() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<int32_t> &getReviewStatus() const noexcept;
+    /// Set the value of the column review_status
+    void setReviewStatus(const int32_t &pReviewStatus) noexcept;
+    void setReviewStatusToNull() noexcept;
+
+    /**  For column submitted_at  */
+    /// Get the value of the column submitted_at, returns the default value if
+    /// the column is null
+    const ::trantor::Date &getValueOfSubmittedAt() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<::trantor::Date> &getSubmittedAt() const noexcept;
+    /// Set the value of the column submitted_at
+    void setSubmittedAt(const ::trantor::Date &pSubmittedAt) noexcept;
+    void setSubmittedAtToNull() noexcept;
+
+    /**  For column display_name  */
+    /// Get the value of the column display_name, returns the default value if
+    /// the column is null
+    const std::string &getValueOfDisplayName() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getDisplayName() const noexcept;
+    /// Set the value of the column display_name
+    void setDisplayName(const std::string &pDisplayName) noexcept;
+    void setDisplayName(std::string &&pDisplayName) noexcept;
+    void setDisplayNameToNull() noexcept;
+
+    static size_t getColumnNumber() noexcept {
+        return 7;
+    }
+    static const std::string &getColumnName(size_t index) noexcept(false);
+
+    Json::Value toJson() const;
+    Json::Value toMasqueradedJson(
+        const std::vector<std::string> &pMasqueradingVector) const;
+    /// Relationship interfaces
+private:
+    friend drogon::orm::Mapper<Gamesubmissions>;
+#ifdef __cpp_impl_coroutine
+    friend drogon::orm::CoroMapper<Gamesubmissions>;
+#endif
+    static const std::vector<std::string> &insertColumns() noexcept;
+    void outputArgs(drogon::orm::internal::SqlBinder &binder) const;
+    const std::vector<std::string> updateColumns() const;
+    void updateArgs(drogon::orm::internal::SqlBinder &binder) const;
+    /// For mysql or sqlite3
+    void updateId(const uint64_t id);
+    std::shared_ptr<std::string> id_;
+    std::shared_ptr<std::string> gameId_;
+    std::shared_ptr<std::string> packageType_;
+    std::shared_ptr<std::string> gitRepo_;
+    std::shared_ptr<int32_t> reviewStatus_;
+    std::shared_ptr<::trantor::Date> submittedAt_;
+    std::shared_ptr<std::string> displayName_;
+    struct MetaData {
+        const std::string colName_;
+        const std::string colType_;
+        const std::string colDatabaseType_;
+        const ssize_t colLength_;
+        const bool isAutoVal_;
+        const bool isPrimaryKey_;
+        const bool notNull_;
+    };
+    static const std::vector<MetaData> metaData_;
+    bool dirtyFlag_[7] = {false};
+
+public:
+    static const std::string &sqlForFindingByPrimaryKey() {
+        static const std::string sql =
+            "select * from " + tableName + " where id = $1";
+        return sql;
+    }
+
+    static const std::string &sqlForDeletingByPrimaryKey() {
+        static const std::string sql =
+            "delete from " + tableName + " where id = $1";
+        return sql;
+    }
+    std::string sqlForInserting(bool &needSelection) const {
+        std::string sql = "insert into " + tableName + " (";
+        size_t parametersCount = 0;
+        needSelection = false;
+        sql += "id,";
+        ++parametersCount;
+        if (!dirtyFlag_[0]) {
+            needSelection = true;
+        }
+        if (dirtyFlag_[1]) {
+            sql += "game_id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[2]) {
+            sql += "package_type,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[3]) {
+            sql += "git_repo,";
+            ++parametersCount;
+        }
+        sql += "review_status,";
+        ++parametersCount;
+        if (!dirtyFlag_[4]) {
+            needSelection = true;
+        }
+        sql += "submitted_at,";
+        ++parametersCount;
+        if (!dirtyFlag_[5]) {
+            needSelection = true;
+        }
+        if (dirtyFlag_[6]) {
+            sql += "display_name,";
+            ++parametersCount;
+        }
+        if (parametersCount > 0) {
+            sql[sql.length() - 1] = ')';
+            sql += " values (";
+        } else
+            sql += ") values (";
+
+        int placeholder = 1;
+        char placeholderStr[64];
+        size_t n = 0;
+        if (dirtyFlag_[0]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        } else {
+            sql += "default,";
+        }
+        if (dirtyFlag_[1]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[2]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[3]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[4]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        } else {
+            sql += "default,";
+        }
+        if (dirtyFlag_[5]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        } else {
+            sql += "default,";
+        }
+        if (dirtyFlag_[6]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (parametersCount > 0) {
+            sql.resize(sql.length() - 1);
+        }
+        if (needSelection) {
+            sql.append(") returning *");
+        } else {
+            sql.append(1, ')');
+        }
+        LOG_TRACE << sql;
+        return sql;
+    }
+};
+}  // namespace cavoke
+}  // namespace drogon_model
diff --git a/server/sql-models/Globalstates.cc b/server/sql-models/Globalstates.cc
new file mode 100644
index 00000000..f3390a76
--- /dev/null
+++ b/server/sql-models/Globalstates.cc
@@ -0,0 +1,752 @@
+/**
+ *
+ *  Globalstates.cc
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#include "Globalstates.h"
+#include <drogon/utils/Utilities.h>
+#include <string>
+
+using namespace drogon;
+using namespace drogon::orm;
+using namespace drogon_model::cavoke_orm;
+
+const std::string Globalstates::Cols::_session_id = "session_id";
+const std::string Globalstates::Cols::_globalstate = "globalstate";
+const std::string Globalstates::Cols::_is_terminal = "is_terminal";
+const std::string Globalstates::Cols::_saved_on = "saved_on";
+const std::string Globalstates::primaryKeyName = "session_id";
+const bool Globalstates::hasPrimaryKey = true;
+const std::string Globalstates::tableName = "globalstates";
+
+const std::vector<typename Globalstates::MetaData> Globalstates::metaData_ = {
+    {"session_id", "std::string", "uuid", 0, 0, 1, 1},
+    {"globalstate", "std::string", "text", 0, 0, 0, 0},
+    {"is_terminal", "bool", "boolean", 1, 0, 0, 1},
+    {"saved_on", "::trantor::Date", "timestamp without time zone", 0, 0, 0, 0}};
+const std::string &Globalstates::getColumnName(size_t index) noexcept(false) {
+    assert(index < metaData_.size());
+    return metaData_[index].colName_;
+}
+Globalstates::Globalstates(const Row &r, const ssize_t indexOffset) noexcept {
+    if (indexOffset < 0) {
+        if (!r["session_id"].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                r["session_id"].as<std::string>());
+        }
+        if (!r["globalstate"].isNull()) {
+            globalstate_ = std::make_shared<std::string>(
+                r["globalstate"].as<std::string>());
+        }
+        if (!r["is_terminal"].isNull()) {
+            isTerminal_ = std::make_shared<bool>(r["is_terminal"].as<bool>());
+        }
+        if (!r["saved_on"].isNull()) {
+            auto timeStr = r["saved_on"].as<std::string>();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    } else {
+        size_t offset = (size_t)indexOffset;
+        if (offset + 4 > r.size()) {
+            LOG_FATAL << "Invalid SQL result for this model";
+            return;
+        }
+        size_t index;
+        index = offset + 0;
+        if (!r[index].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 1;
+        if (!r[index].isNull()) {
+            globalstate_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 2;
+        if (!r[index].isNull()) {
+            isTerminal_ = std::make_shared<bool>(r[index].as<bool>());
+        }
+        index = offset + 3;
+        if (!r[index].isNull()) {
+            auto timeStr = r[index].as<std::string>();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+}
+
+Globalstates::Globalstates(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 4) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        dirtyFlag_[0] = true;
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            globalstate_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            isTerminal_ =
+                std::make_shared<bool>(pJson[pMasqueradingVector[2]].asBool());
+        }
+    }
+    if (!pMasqueradingVector[3].empty() &&
+        pJson.isMember(pMasqueradingVector[3])) {
+        dirtyFlag_[3] = true;
+        if (!pJson[pMasqueradingVector[3]].isNull()) {
+            auto timeStr = pJson[pMasqueradingVector[3]].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+}
+
+Globalstates::Globalstates(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("session_id")) {
+        dirtyFlag_[0] = true;
+        if (!pJson["session_id"].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(pJson["session_id"].asString());
+        }
+    }
+    if (pJson.isMember("globalstate")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["globalstate"].isNull()) {
+            globalstate_ =
+                std::make_shared<std::string>(pJson["globalstate"].asString());
+        }
+    }
+    if (pJson.isMember("is_terminal")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["is_terminal"].isNull()) {
+            isTerminal_ = std::make_shared<bool>(pJson["is_terminal"].asBool());
+        }
+    }
+    if (pJson.isMember("saved_on")) {
+        dirtyFlag_[3] = true;
+        if (!pJson["saved_on"].isNull()) {
+            auto timeStr = pJson["saved_on"].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+}
+
+void Globalstates::updateByMasqueradedJson(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 4) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            globalstate_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            isTerminal_ =
+                std::make_shared<bool>(pJson[pMasqueradingVector[2]].asBool());
+        }
+    }
+    if (!pMasqueradingVector[3].empty() &&
+        pJson.isMember(pMasqueradingVector[3])) {
+        dirtyFlag_[3] = true;
+        if (!pJson[pMasqueradingVector[3]].isNull()) {
+            auto timeStr = pJson[pMasqueradingVector[3]].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+}
+
+void Globalstates::updateByJson(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("session_id")) {
+        if (!pJson["session_id"].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(pJson["session_id"].asString());
+        }
+    }
+    if (pJson.isMember("globalstate")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["globalstate"].isNull()) {
+            globalstate_ =
+                std::make_shared<std::string>(pJson["globalstate"].asString());
+        }
+    }
+    if (pJson.isMember("is_terminal")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["is_terminal"].isNull()) {
+            isTerminal_ = std::make_shared<bool>(pJson["is_terminal"].asBool());
+        }
+    }
+    if (pJson.isMember("saved_on")) {
+        dirtyFlag_[3] = true;
+        if (!pJson["saved_on"].isNull()) {
+            auto timeStr = pJson["saved_on"].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+}
+
+const std::string &Globalstates::getValueOfSessionId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (sessionId_)
+        return *sessionId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Globalstates::getSessionId()
+    const noexcept {
+    return sessionId_;
+}
+void Globalstates::setSessionId(const std::string &pSessionId) noexcept {
+    sessionId_ = std::make_shared<std::string>(pSessionId);
+    dirtyFlag_[0] = true;
+}
+void Globalstates::setSessionId(std::string &&pSessionId) noexcept {
+    sessionId_ = std::make_shared<std::string>(std::move(pSessionId));
+    dirtyFlag_[0] = true;
+}
+const typename Globalstates::PrimaryKeyType &Globalstates::getPrimaryKey()
+    const {
+    assert(sessionId_);
+    return *sessionId_;
+}
+
+const std::string &Globalstates::getValueOfGlobalstate() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (globalstate_)
+        return *globalstate_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Globalstates::getGlobalstate()
+    const noexcept {
+    return globalstate_;
+}
+void Globalstates::setGlobalstate(const std::string &pGlobalstate) noexcept {
+    globalstate_ = std::make_shared<std::string>(pGlobalstate);
+    dirtyFlag_[1] = true;
+}
+void Globalstates::setGlobalstate(std::string &&pGlobalstate) noexcept {
+    globalstate_ = std::make_shared<std::string>(std::move(pGlobalstate));
+    dirtyFlag_[1] = true;
+}
+void Globalstates::setGlobalstateToNull() noexcept {
+    globalstate_.reset();
+    dirtyFlag_[1] = true;
+}
+
+const bool &Globalstates::getValueOfIsTerminal() const noexcept {
+    const static bool defaultValue = bool();
+    if (isTerminal_)
+        return *isTerminal_;
+    return defaultValue;
+}
+const std::shared_ptr<bool> &Globalstates::getIsTerminal() const noexcept {
+    return isTerminal_;
+}
+void Globalstates::setIsTerminal(const bool &pIsTerminal) noexcept {
+    isTerminal_ = std::make_shared<bool>(pIsTerminal);
+    dirtyFlag_[2] = true;
+}
+
+const ::trantor::Date &Globalstates::getValueOfSavedOn() const noexcept {
+    const static ::trantor::Date defaultValue = ::trantor::Date();
+    if (savedOn_)
+        return *savedOn_;
+    return defaultValue;
+}
+const std::shared_ptr<::trantor::Date> &Globalstates::getSavedOn()
+    const noexcept {
+    return savedOn_;
+}
+void Globalstates::setSavedOn(const ::trantor::Date &pSavedOn) noexcept {
+    savedOn_ = std::make_shared<::trantor::Date>(pSavedOn);
+    dirtyFlag_[3] = true;
+}
+void Globalstates::setSavedOnToNull() noexcept {
+    savedOn_.reset();
+    dirtyFlag_[3] = true;
+}
+
+void Globalstates::updateId(const uint64_t id) {
+}
+
+const std::vector<std::string> &Globalstates::insertColumns() noexcept {
+    static const std::vector<std::string> inCols = {"session_id", "globalstate",
+                                                    "is_terminal", "saved_on"};
+    return inCols;
+}
+
+void Globalstates::outputArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getSessionId()) {
+            binder << getValueOfSessionId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getGlobalstate()) {
+            binder << getValueOfGlobalstate();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getIsTerminal()) {
+            binder << getValueOfIsTerminal();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[3]) {
+        if (getSavedOn()) {
+            binder << getValueOfSavedOn();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+
+const std::vector<std::string> Globalstates::updateColumns() const {
+    std::vector<std::string> ret;
+    if (dirtyFlag_[0]) {
+        ret.push_back(getColumnName(0));
+    }
+    if (dirtyFlag_[1]) {
+        ret.push_back(getColumnName(1));
+    }
+    if (dirtyFlag_[2]) {
+        ret.push_back(getColumnName(2));
+    }
+    if (dirtyFlag_[3]) {
+        ret.push_back(getColumnName(3));
+    }
+    return ret;
+}
+
+void Globalstates::updateArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getSessionId()) {
+            binder << getValueOfSessionId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getGlobalstate()) {
+            binder << getValueOfGlobalstate();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getIsTerminal()) {
+            binder << getValueOfIsTerminal();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[3]) {
+        if (getSavedOn()) {
+            binder << getValueOfSavedOn();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+Json::Value Globalstates::toJson() const {
+    Json::Value ret;
+    if (getSessionId()) {
+        ret["session_id"] = getValueOfSessionId();
+    } else {
+        ret["session_id"] = Json::Value();
+    }
+    if (getGlobalstate()) {
+        ret["globalstate"] = getValueOfGlobalstate();
+    } else {
+        ret["globalstate"] = Json::Value();
+    }
+    if (getIsTerminal()) {
+        ret["is_terminal"] = getValueOfIsTerminal();
+    } else {
+        ret["is_terminal"] = Json::Value();
+    }
+    if (getSavedOn()) {
+        ret["saved_on"] = getSavedOn()->toDbStringLocal();
+    } else {
+        ret["saved_on"] = Json::Value();
+    }
+    return ret;
+}
+
+Json::Value Globalstates::toMasqueradedJson(
+    const std::vector<std::string> &pMasqueradingVector) const {
+    Json::Value ret;
+    if (pMasqueradingVector.size() == 4) {
+        if (!pMasqueradingVector[0].empty()) {
+            if (getSessionId()) {
+                ret[pMasqueradingVector[0]] = getValueOfSessionId();
+            } else {
+                ret[pMasqueradingVector[0]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (getGlobalstate()) {
+                ret[pMasqueradingVector[1]] = getValueOfGlobalstate();
+            } else {
+                ret[pMasqueradingVector[1]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (getIsTerminal()) {
+                ret[pMasqueradingVector[2]] = getValueOfIsTerminal();
+            } else {
+                ret[pMasqueradingVector[2]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[3].empty()) {
+            if (getSavedOn()) {
+                ret[pMasqueradingVector[3]] = getSavedOn()->toDbStringLocal();
+            } else {
+                ret[pMasqueradingVector[3]] = Json::Value();
+            }
+        }
+        return ret;
+    }
+    LOG_ERROR << "Masquerade failed";
+    if (getSessionId()) {
+        ret["session_id"] = getValueOfSessionId();
+    } else {
+        ret["session_id"] = Json::Value();
+    }
+    if (getGlobalstate()) {
+        ret["globalstate"] = getValueOfGlobalstate();
+    } else {
+        ret["globalstate"] = Json::Value();
+    }
+    if (getIsTerminal()) {
+        ret["is_terminal"] = getValueOfIsTerminal();
+    } else {
+        ret["is_terminal"] = Json::Value();
+    }
+    if (getSavedOn()) {
+        ret["saved_on"] = getSavedOn()->toDbStringLocal();
+    } else {
+        ret["saved_on"] = Json::Value();
+    }
+    return ret;
+}
+
+bool Globalstates::validateJsonForCreation(const Json::Value &pJson,
+                                           std::string &err) {
+    if (pJson.isMember("session_id")) {
+        if (!validJsonOfField(0, "session_id", pJson["session_id"], err, true))
+            return false;
+    } else {
+        err = "The session_id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("globalstate")) {
+        if (!validJsonOfField(1, "globalstate", pJson["globalstate"], err,
+                              true))
+            return false;
+    }
+    if (pJson.isMember("is_terminal")) {
+        if (!validJsonOfField(2, "is_terminal", pJson["is_terminal"], err,
+                              true))
+            return false;
+    }
+    if (pJson.isMember("saved_on")) {
+        if (!validJsonOfField(3, "saved_on", pJson["saved_on"], err, true))
+            return false;
+    }
+    return true;
+}
+bool Globalstates::validateMasqueradedJsonForCreation(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 4) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty()) {
+            if (pJson.isMember(pMasqueradingVector[0])) {
+                if (!validJsonOfField(0, pMasqueradingVector[0],
+                                      pJson[pMasqueradingVector[0]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[0] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (pJson.isMember(pMasqueradingVector[1])) {
+                if (!validJsonOfField(1, pMasqueradingVector[1],
+                                      pJson[pMasqueradingVector[1]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (pJson.isMember(pMasqueradingVector[2])) {
+                if (!validJsonOfField(2, pMasqueradingVector[2],
+                                      pJson[pMasqueradingVector[2]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[3].empty()) {
+            if (pJson.isMember(pMasqueradingVector[3])) {
+                if (!validJsonOfField(3, pMasqueradingVector[3],
+                                      pJson[pMasqueradingVector[3]], err, true))
+                    return false;
+            }
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Globalstates::validateJsonForUpdate(const Json::Value &pJson,
+                                         std::string &err) {
+    if (pJson.isMember("session_id")) {
+        if (!validJsonOfField(0, "session_id", pJson["session_id"], err, false))
+            return false;
+    } else {
+        err =
+            "The value of primary key must be set in the json object for "
+            "update";
+        return false;
+    }
+    if (pJson.isMember("globalstate")) {
+        if (!validJsonOfField(1, "globalstate", pJson["globalstate"], err,
+                              false))
+            return false;
+    }
+    if (pJson.isMember("is_terminal")) {
+        if (!validJsonOfField(2, "is_terminal", pJson["is_terminal"], err,
+                              false))
+            return false;
+    }
+    if (pJson.isMember("saved_on")) {
+        if (!validJsonOfField(3, "saved_on", pJson["saved_on"], err, false))
+            return false;
+    }
+    return true;
+}
+bool Globalstates::validateMasqueradedJsonForUpdate(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 4) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty() &&
+            pJson.isMember(pMasqueradingVector[0])) {
+            if (!validJsonOfField(0, pMasqueradingVector[0],
+                                  pJson[pMasqueradingVector[0]], err, false))
+                return false;
+        } else {
+            err =
+                "The value of primary key must be set in the json object for "
+                "update";
+            return false;
+        }
+        if (!pMasqueradingVector[1].empty() &&
+            pJson.isMember(pMasqueradingVector[1])) {
+            if (!validJsonOfField(1, pMasqueradingVector[1],
+                                  pJson[pMasqueradingVector[1]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[2].empty() &&
+            pJson.isMember(pMasqueradingVector[2])) {
+            if (!validJsonOfField(2, pMasqueradingVector[2],
+                                  pJson[pMasqueradingVector[2]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[3].empty() &&
+            pJson.isMember(pMasqueradingVector[3])) {
+            if (!validJsonOfField(3, pMasqueradingVector[3],
+                                  pJson[pMasqueradingVector[3]], err, false))
+                return false;
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Globalstates::validJsonOfField(size_t index,
+                                    const std::string &fieldName,
+                                    const Json::Value &pJson,
+                                    std::string &err,
+                                    bool isForCreation) {
+    switch (index) {
+        case 0:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 1:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 2:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isBool()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 3:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        default:
+            err = "Internal error in the server";
+            return false;
+            break;
+    }
+    return true;
+}
diff --git a/server/sql-models/Globalstates.h b/server/sql-models/Globalstates.h
new file mode 100644
index 00000000..1dd4b5c5
--- /dev/null
+++ b/server/sql-models/Globalstates.h
@@ -0,0 +1,258 @@
+/**
+ *
+ *  Globalstates.h
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#pragma once
+#include <drogon/orm/Field.h>
+#include <drogon/orm/Mapper.h>
+#include <drogon/orm/Result.h>
+#include <drogon/orm/Row.h>
+#include <drogon/orm/SqlBinder.h>
+#ifdef __cpp_impl_coroutine
+#include <drogon/orm/CoroMapper.h>
+#endif
+#include <json/json.h>
+#include <stdint.h>
+#include <trantor/utils/Date.h>
+#include <trantor/utils/Logger.h>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace drogon {
+namespace orm {
+class DbClient;
+using DbClientPtr = std::shared_ptr<DbClient>;
+}  // namespace orm
+}  // namespace drogon
+namespace drogon_model {
+namespace cavoke_orm {
+
+class Globalstates {
+public:
+    struct Cols {
+        static const std::string _session_id;
+        static const std::string _globalstate;
+        static const std::string _is_terminal;
+        static const std::string _saved_on;
+    };
+
+    const static int primaryKeyNumber;
+    const static std::string tableName;
+    const static bool hasPrimaryKey;
+    const static std::string primaryKeyName;
+    using PrimaryKeyType = std::string;
+    const PrimaryKeyType &getPrimaryKey() const;
+
+    /**
+     * @brief constructor
+     * @param r One row of records in the SQL query result.
+     * @param indexOffset Set the offset to -1 to access all columns by column
+     * names, otherwise access all columns by offsets.
+     * @note If the SQL is not a style of 'select * from table_name ...' (select
+     * all columns by an asterisk), please set the offset to -1.
+     */
+    explicit Globalstates(const drogon::orm::Row &r,
+                          const ssize_t indexOffset = 0) noexcept;
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     */
+    explicit Globalstates(const Json::Value &pJson) noexcept(false);
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     * @param pMasqueradingVector The aliases of table columns.
+     */
+    Globalstates(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+
+    Globalstates() = default;
+
+    void updateByJson(const Json::Value &pJson) noexcept(false);
+    void updateByMasqueradedJson(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+    static bool validateJsonForCreation(const Json::Value &pJson,
+                                        std::string &err);
+    static bool validateMasqueradedJsonForCreation(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validateJsonForUpdate(const Json::Value &pJson,
+                                      std::string &err);
+    static bool validateMasqueradedJsonForUpdate(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validJsonOfField(size_t index,
+                                 const std::string &fieldName,
+                                 const Json::Value &pJson,
+                                 std::string &err,
+                                 bool isForCreation);
+
+    /**  For column session_id  */
+    /// Get the value of the column session_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfSessionId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getSessionId() const noexcept;
+    /// Set the value of the column session_id
+    void setSessionId(const std::string &pSessionId) noexcept;
+    void setSessionId(std::string &&pSessionId) noexcept;
+
+    /**  For column globalstate  */
+    /// Get the value of the column globalstate, returns the default value if
+    /// the column is null
+    const std::string &getValueOfGlobalstate() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getGlobalstate() const noexcept;
+    /// Set the value of the column globalstate
+    void setGlobalstate(const std::string &pGlobalstate) noexcept;
+    void setGlobalstate(std::string &&pGlobalstate) noexcept;
+    void setGlobalstateToNull() noexcept;
+
+    /**  For column is_terminal  */
+    /// Get the value of the column is_terminal, returns the default value if
+    /// the column is null
+    const bool &getValueOfIsTerminal() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<bool> &getIsTerminal() const noexcept;
+    /// Set the value of the column is_terminal
+    void setIsTerminal(const bool &pIsTerminal) noexcept;
+
+    /**  For column saved_on  */
+    /// Get the value of the column saved_on, returns the default value if the
+    /// column is null
+    const ::trantor::Date &getValueOfSavedOn() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<::trantor::Date> &getSavedOn() const noexcept;
+    /// Set the value of the column saved_on
+    void setSavedOn(const ::trantor::Date &pSavedOn) noexcept;
+    void setSavedOnToNull() noexcept;
+
+    static size_t getColumnNumber() noexcept {
+        return 4;
+    }
+    static const std::string &getColumnName(size_t index) noexcept(false);
+
+    Json::Value toJson() const;
+    Json::Value toMasqueradedJson(
+        const std::vector<std::string> &pMasqueradingVector) const;
+    /// Relationship interfaces
+private:
+    friend drogon::orm::Mapper<Globalstates>;
+#ifdef __cpp_impl_coroutine
+    friend drogon::orm::CoroMapper<Globalstates>;
+#endif
+    static const std::vector<std::string> &insertColumns() noexcept;
+    void outputArgs(drogon::orm::internal::SqlBinder &binder) const;
+    const std::vector<std::string> updateColumns() const;
+    void updateArgs(drogon::orm::internal::SqlBinder &binder) const;
+    /// For mysql or sqlite3
+    void updateId(const uint64_t id);
+    std::shared_ptr<std::string> sessionId_;
+    std::shared_ptr<std::string> globalstate_;
+    std::shared_ptr<bool> isTerminal_;
+    std::shared_ptr<::trantor::Date> savedOn_;
+    struct MetaData {
+        const std::string colName_;
+        const std::string colType_;
+        const std::string colDatabaseType_;
+        const ssize_t colLength_;
+        const bool isAutoVal_;
+        const bool isPrimaryKey_;
+        const bool notNull_;
+    };
+    static const std::vector<MetaData> metaData_;
+    bool dirtyFlag_[4] = {false};
+
+public:
+    static const std::string &sqlForFindingByPrimaryKey() {
+        static const std::string sql =
+            "select * from " + tableName + " where session_id = $1";
+        return sql;
+    }
+
+    static const std::string &sqlForDeletingByPrimaryKey() {
+        static const std::string sql =
+            "delete from " + tableName + " where session_id = $1";
+        return sql;
+    }
+    std::string sqlForInserting(bool &needSelection) const {
+        std::string sql = "insert into " + tableName + " (";
+        size_t parametersCount = 0;
+        needSelection = false;
+        if (dirtyFlag_[0]) {
+            sql += "session_id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[1]) {
+            sql += "globalstate,";
+            ++parametersCount;
+        }
+        sql += "is_terminal,";
+        ++parametersCount;
+        if (!dirtyFlag_[2]) {
+            needSelection = true;
+        }
+        sql += "saved_on,";
+        ++parametersCount;
+        if (!dirtyFlag_[3]) {
+            needSelection = true;
+        }
+        if (parametersCount > 0) {
+            sql[sql.length() - 1] = ')';
+            sql += " values (";
+        } else
+            sql += ") values (";
+
+        int placeholder = 1;
+        char placeholderStr[64];
+        size_t n = 0;
+        if (dirtyFlag_[0]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[1]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[2]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        } else {
+            sql += "default,";
+        }
+        if (dirtyFlag_[3]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        } else {
+            sql += "default,";
+        }
+        if (parametersCount > 0) {
+            sql.resize(sql.length() - 1);
+        }
+        if (needSelection) {
+            sql.append(") returning *");
+        } else {
+            sql.append(1, ')');
+        }
+        LOG_TRACE << sql;
+        return sql;
+    }
+};
+}  // namespace cavoke_orm
+}  // namespace drogon_model
diff --git a/server/sql-models/Players.cc b/server/sql-models/Players.cc
new file mode 100644
index 00000000..eea26887
--- /dev/null
+++ b/server/sql-models/Players.cc
@@ -0,0 +1,837 @@
+/**
+ *
+ *  Players.cc
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#include "Players.h"
+#include <drogon/utils/Utilities.h>
+#include <string>
+#include "Sessions.h"
+#include "Users.h"
+
+using namespace drogon;
+using namespace drogon::orm;
+using namespace drogon_model::cavoke_orm;
+
+const std::string Players::Cols::_session_id = "session_id";
+const std::string Players::Cols::_user_id = "user_id";
+const std::string Players::Cols::_player_id = "player_id";
+const std::string Players::Cols::_score = "score";
+const std::string Players::Cols::_playerstate = "playerstate";
+const std::vector<std::string> Players::primaryKeyName = {"session_id",
+                                                          "user_id"};
+const bool Players::hasPrimaryKey = true;
+const std::string Players::tableName = "players";
+
+const std::vector<typename Players::MetaData> Players::metaData_ = {
+    {"session_id", "std::string", "uuid", 0, 0, 1, 1},
+    {"user_id", "std::string", "character varying", 0, 0, 1, 1},
+    {"player_id", "int32_t", "integer", 4, 0, 0, 1},
+    {"score", "int32_t", "integer", 4, 0, 0, 0},
+    {"playerstate", "std::string", "text", 0, 0, 0, 1}};
+const std::string &Players::getColumnName(size_t index) noexcept(false) {
+    assert(index < metaData_.size());
+    return metaData_[index].colName_;
+}
+Players::Players(const Row &r, const ssize_t indexOffset) noexcept {
+    if (indexOffset < 0) {
+        if (!r["session_id"].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                r["session_id"].as<std::string>());
+        }
+        if (!r["user_id"].isNull()) {
+            userId_ =
+                std::make_shared<std::string>(r["user_id"].as<std::string>());
+        }
+        if (!r["player_id"].isNull()) {
+            playerId_ = std::make_shared<int32_t>(r["player_id"].as<int32_t>());
+        }
+        if (!r["score"].isNull()) {
+            score_ = std::make_shared<int32_t>(r["score"].as<int32_t>());
+        }
+        if (!r["playerstate"].isNull()) {
+            playerstate_ = std::make_shared<std::string>(
+                r["playerstate"].as<std::string>());
+        }
+    } else {
+        size_t offset = (size_t)indexOffset;
+        if (offset + 5 > r.size()) {
+            LOG_FATAL << "Invalid SQL result for this model";
+            return;
+        }
+        size_t index;
+        index = offset + 0;
+        if (!r[index].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 1;
+        if (!r[index].isNull()) {
+            userId_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 2;
+        if (!r[index].isNull()) {
+            playerId_ = std::make_shared<int32_t>(r[index].as<int32_t>());
+        }
+        index = offset + 3;
+        if (!r[index].isNull()) {
+            score_ = std::make_shared<int32_t>(r[index].as<int32_t>());
+        }
+        index = offset + 4;
+        if (!r[index].isNull()) {
+            playerstate_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+    }
+}
+
+Players::Players(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 5) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        dirtyFlag_[0] = true;
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            userId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            playerId_ = std::make_shared<int32_t>(
+                (int32_t)pJson[pMasqueradingVector[2]].asInt64());
+        }
+    }
+    if (!pMasqueradingVector[3].empty() &&
+        pJson.isMember(pMasqueradingVector[3])) {
+        dirtyFlag_[3] = true;
+        if (!pJson[pMasqueradingVector[3]].isNull()) {
+            score_ = std::make_shared<int32_t>(
+                (int32_t)pJson[pMasqueradingVector[3]].asInt64());
+        }
+    }
+    if (!pMasqueradingVector[4].empty() &&
+        pJson.isMember(pMasqueradingVector[4])) {
+        dirtyFlag_[4] = true;
+        if (!pJson[pMasqueradingVector[4]].isNull()) {
+            playerstate_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[4]].asString());
+        }
+    }
+}
+
+Players::Players(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("session_id")) {
+        dirtyFlag_[0] = true;
+        if (!pJson["session_id"].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(pJson["session_id"].asString());
+        }
+    }
+    if (pJson.isMember("user_id")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["user_id"].isNull()) {
+            userId_ =
+                std::make_shared<std::string>(pJson["user_id"].asString());
+        }
+    }
+    if (pJson.isMember("player_id")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["player_id"].isNull()) {
+            playerId_ = std::make_shared<int32_t>(
+                (int32_t)pJson["player_id"].asInt64());
+        }
+    }
+    if (pJson.isMember("score")) {
+        dirtyFlag_[3] = true;
+        if (!pJson["score"].isNull()) {
+            score_ =
+                std::make_shared<int32_t>((int32_t)pJson["score"].asInt64());
+        }
+    }
+    if (pJson.isMember("playerstate")) {
+        dirtyFlag_[4] = true;
+        if (!pJson["playerstate"].isNull()) {
+            playerstate_ =
+                std::make_shared<std::string>(pJson["playerstate"].asString());
+        }
+    }
+}
+
+void Players::updateByMasqueradedJson(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 5) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            userId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            playerId_ = std::make_shared<int32_t>(
+                (int32_t)pJson[pMasqueradingVector[2]].asInt64());
+        }
+    }
+    if (!pMasqueradingVector[3].empty() &&
+        pJson.isMember(pMasqueradingVector[3])) {
+        dirtyFlag_[3] = true;
+        if (!pJson[pMasqueradingVector[3]].isNull()) {
+            score_ = std::make_shared<int32_t>(
+                (int32_t)pJson[pMasqueradingVector[3]].asInt64());
+        }
+    }
+    if (!pMasqueradingVector[4].empty() &&
+        pJson.isMember(pMasqueradingVector[4])) {
+        dirtyFlag_[4] = true;
+        if (!pJson[pMasqueradingVector[4]].isNull()) {
+            playerstate_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[4]].asString());
+        }
+    }
+}
+
+void Players::updateByJson(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("session_id")) {
+        if (!pJson["session_id"].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(pJson["session_id"].asString());
+        }
+    }
+    if (pJson.isMember("user_id")) {
+        if (!pJson["user_id"].isNull()) {
+            userId_ =
+                std::make_shared<std::string>(pJson["user_id"].asString());
+        }
+    }
+    if (pJson.isMember("player_id")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["player_id"].isNull()) {
+            playerId_ = std::make_shared<int32_t>(
+                (int32_t)pJson["player_id"].asInt64());
+        }
+    }
+    if (pJson.isMember("score")) {
+        dirtyFlag_[3] = true;
+        if (!pJson["score"].isNull()) {
+            score_ =
+                std::make_shared<int32_t>((int32_t)pJson["score"].asInt64());
+        }
+    }
+    if (pJson.isMember("playerstate")) {
+        dirtyFlag_[4] = true;
+        if (!pJson["playerstate"].isNull()) {
+            playerstate_ =
+                std::make_shared<std::string>(pJson["playerstate"].asString());
+        }
+    }
+}
+
+const std::string &Players::getValueOfSessionId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (sessionId_)
+        return *sessionId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Players::getSessionId() const noexcept {
+    return sessionId_;
+}
+void Players::setSessionId(const std::string &pSessionId) noexcept {
+    sessionId_ = std::make_shared<std::string>(pSessionId);
+    dirtyFlag_[0] = true;
+}
+void Players::setSessionId(std::string &&pSessionId) noexcept {
+    sessionId_ = std::make_shared<std::string>(std::move(pSessionId));
+    dirtyFlag_[0] = true;
+}
+
+const std::string &Players::getValueOfUserId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (userId_)
+        return *userId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Players::getUserId() const noexcept {
+    return userId_;
+}
+void Players::setUserId(const std::string &pUserId) noexcept {
+    userId_ = std::make_shared<std::string>(pUserId);
+    dirtyFlag_[1] = true;
+}
+void Players::setUserId(std::string &&pUserId) noexcept {
+    userId_ = std::make_shared<std::string>(std::move(pUserId));
+    dirtyFlag_[1] = true;
+}
+
+const int32_t &Players::getValueOfPlayerId() const noexcept {
+    const static int32_t defaultValue = int32_t();
+    if (playerId_)
+        return *playerId_;
+    return defaultValue;
+}
+const std::shared_ptr<int32_t> &Players::getPlayerId() const noexcept {
+    return playerId_;
+}
+void Players::setPlayerId(const int32_t &pPlayerId) noexcept {
+    playerId_ = std::make_shared<int32_t>(pPlayerId);
+    dirtyFlag_[2] = true;
+}
+
+const int32_t &Players::getValueOfScore() const noexcept {
+    const static int32_t defaultValue = int32_t();
+    if (score_)
+        return *score_;
+    return defaultValue;
+}
+const std::shared_ptr<int32_t> &Players::getScore() const noexcept {
+    return score_;
+}
+void Players::setScore(const int32_t &pScore) noexcept {
+    score_ = std::make_shared<int32_t>(pScore);
+    dirtyFlag_[3] = true;
+}
+void Players::setScoreToNull() noexcept {
+    score_.reset();
+    dirtyFlag_[3] = true;
+}
+
+const std::string &Players::getValueOfPlayerstate() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (playerstate_)
+        return *playerstate_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Players::getPlayerstate() const noexcept {
+    return playerstate_;
+}
+void Players::setPlayerstate(const std::string &pPlayerstate) noexcept {
+    playerstate_ = std::make_shared<std::string>(pPlayerstate);
+    dirtyFlag_[4] = true;
+}
+void Players::setPlayerstate(std::string &&pPlayerstate) noexcept {
+    playerstate_ = std::make_shared<std::string>(std::move(pPlayerstate));
+    dirtyFlag_[4] = true;
+}
+
+void Players::updateId(const uint64_t id) {
+}
+typename Players::PrimaryKeyType Players::getPrimaryKey() const {
+    return std::make_tuple(*sessionId_, *userId_);
+}
+
+const std::vector<std::string> &Players::insertColumns() noexcept {
+    static const std::vector<std::string> inCols = {
+        "session_id", "user_id", "player_id", "score", "playerstate"};
+    return inCols;
+}
+
+void Players::outputArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getSessionId()) {
+            binder << getValueOfSessionId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getUserId()) {
+            binder << getValueOfUserId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getPlayerId()) {
+            binder << getValueOfPlayerId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[3]) {
+        if (getScore()) {
+            binder << getValueOfScore();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[4]) {
+        if (getPlayerstate()) {
+            binder << getValueOfPlayerstate();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+
+const std::vector<std::string> Players::updateColumns() const {
+    std::vector<std::string> ret;
+    if (dirtyFlag_[0]) {
+        ret.push_back(getColumnName(0));
+    }
+    if (dirtyFlag_[1]) {
+        ret.push_back(getColumnName(1));
+    }
+    if (dirtyFlag_[2]) {
+        ret.push_back(getColumnName(2));
+    }
+    if (dirtyFlag_[3]) {
+        ret.push_back(getColumnName(3));
+    }
+    if (dirtyFlag_[4]) {
+        ret.push_back(getColumnName(4));
+    }
+    return ret;
+}
+
+void Players::updateArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getSessionId()) {
+            binder << getValueOfSessionId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getUserId()) {
+            binder << getValueOfUserId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getPlayerId()) {
+            binder << getValueOfPlayerId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[3]) {
+        if (getScore()) {
+            binder << getValueOfScore();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[4]) {
+        if (getPlayerstate()) {
+            binder << getValueOfPlayerstate();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+Json::Value Players::toJson() const {
+    Json::Value ret;
+    if (getSessionId()) {
+        ret["session_id"] = getValueOfSessionId();
+    } else {
+        ret["session_id"] = Json::Value();
+    }
+    if (getUserId()) {
+        ret["user_id"] = getValueOfUserId();
+    } else {
+        ret["user_id"] = Json::Value();
+    }
+    if (getPlayerId()) {
+        ret["player_id"] = getValueOfPlayerId();
+    } else {
+        ret["player_id"] = Json::Value();
+    }
+    if (getScore()) {
+        ret["score"] = getValueOfScore();
+    } else {
+        ret["score"] = Json::Value();
+    }
+    if (getPlayerstate()) {
+        ret["playerstate"] = getValueOfPlayerstate();
+    } else {
+        ret["playerstate"] = Json::Value();
+    }
+    return ret;
+}
+
+Json::Value Players::toMasqueradedJson(
+    const std::vector<std::string> &pMasqueradingVector) const {
+    Json::Value ret;
+    if (pMasqueradingVector.size() == 5) {
+        if (!pMasqueradingVector[0].empty()) {
+            if (getSessionId()) {
+                ret[pMasqueradingVector[0]] = getValueOfSessionId();
+            } else {
+                ret[pMasqueradingVector[0]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (getUserId()) {
+                ret[pMasqueradingVector[1]] = getValueOfUserId();
+            } else {
+                ret[pMasqueradingVector[1]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (getPlayerId()) {
+                ret[pMasqueradingVector[2]] = getValueOfPlayerId();
+            } else {
+                ret[pMasqueradingVector[2]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[3].empty()) {
+            if (getScore()) {
+                ret[pMasqueradingVector[3]] = getValueOfScore();
+            } else {
+                ret[pMasqueradingVector[3]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[4].empty()) {
+            if (getPlayerstate()) {
+                ret[pMasqueradingVector[4]] = getValueOfPlayerstate();
+            } else {
+                ret[pMasqueradingVector[4]] = Json::Value();
+            }
+        }
+        return ret;
+    }
+    LOG_ERROR << "Masquerade failed";
+    if (getSessionId()) {
+        ret["session_id"] = getValueOfSessionId();
+    } else {
+        ret["session_id"] = Json::Value();
+    }
+    if (getUserId()) {
+        ret["user_id"] = getValueOfUserId();
+    } else {
+        ret["user_id"] = Json::Value();
+    }
+    if (getPlayerId()) {
+        ret["player_id"] = getValueOfPlayerId();
+    } else {
+        ret["player_id"] = Json::Value();
+    }
+    if (getScore()) {
+        ret["score"] = getValueOfScore();
+    } else {
+        ret["score"] = Json::Value();
+    }
+    if (getPlayerstate()) {
+        ret["playerstate"] = getValueOfPlayerstate();
+    } else {
+        ret["playerstate"] = Json::Value();
+    }
+    return ret;
+}
+
+bool Players::validateJsonForCreation(const Json::Value &pJson,
+                                      std::string &err) {
+    if (pJson.isMember("session_id")) {
+        if (!validJsonOfField(0, "session_id", pJson["session_id"], err, true))
+            return false;
+    } else {
+        err = "The session_id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("user_id")) {
+        if (!validJsonOfField(1, "user_id", pJson["user_id"], err, true))
+            return false;
+    } else {
+        err = "The user_id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("player_id")) {
+        if (!validJsonOfField(2, "player_id", pJson["player_id"], err, true))
+            return false;
+    } else {
+        err = "The player_id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("score")) {
+        if (!validJsonOfField(3, "score", pJson["score"], err, true))
+            return false;
+    }
+    if (pJson.isMember("playerstate")) {
+        if (!validJsonOfField(4, "playerstate", pJson["playerstate"], err,
+                              true))
+            return false;
+    } else {
+        err = "The playerstate column cannot be null";
+        return false;
+    }
+    return true;
+}
+bool Players::validateMasqueradedJsonForCreation(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 5) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty()) {
+            if (pJson.isMember(pMasqueradingVector[0])) {
+                if (!validJsonOfField(0, pMasqueradingVector[0],
+                                      pJson[pMasqueradingVector[0]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[0] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (pJson.isMember(pMasqueradingVector[1])) {
+                if (!validJsonOfField(1, pMasqueradingVector[1],
+                                      pJson[pMasqueradingVector[1]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[1] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (pJson.isMember(pMasqueradingVector[2])) {
+                if (!validJsonOfField(2, pMasqueradingVector[2],
+                                      pJson[pMasqueradingVector[2]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[2] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[3].empty()) {
+            if (pJson.isMember(pMasqueradingVector[3])) {
+                if (!validJsonOfField(3, pMasqueradingVector[3],
+                                      pJson[pMasqueradingVector[3]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[4].empty()) {
+            if (pJson.isMember(pMasqueradingVector[4])) {
+                if (!validJsonOfField(4, pMasqueradingVector[4],
+                                      pJson[pMasqueradingVector[4]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[4] + " column cannot be null";
+                return false;
+            }
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Players::validateJsonForUpdate(const Json::Value &pJson,
+                                    std::string &err) {
+    if (pJson.isMember("session_id")) {
+        if (!validJsonOfField(0, "session_id", pJson["session_id"], err, false))
+            return false;
+    } else {
+        err =
+            "The value of primary key must be set in the json object for "
+            "update";
+        return false;
+    }
+    if (pJson.isMember("user_id")) {
+        if (!validJsonOfField(1, "user_id", pJson["user_id"], err, false))
+            return false;
+    } else {
+        err =
+            "The value of primary key must be set in the json object for "
+            "update";
+        return false;
+    }
+    if (pJson.isMember("player_id")) {
+        if (!validJsonOfField(2, "player_id", pJson["player_id"], err, false))
+            return false;
+    }
+    if (pJson.isMember("score")) {
+        if (!validJsonOfField(3, "score", pJson["score"], err, false))
+            return false;
+    }
+    if (pJson.isMember("playerstate")) {
+        if (!validJsonOfField(4, "playerstate", pJson["playerstate"], err,
+                              false))
+            return false;
+    }
+    return true;
+}
+bool Players::validateMasqueradedJsonForUpdate(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 5) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty() &&
+            pJson.isMember(pMasqueradingVector[0])) {
+            if (!validJsonOfField(0, pMasqueradingVector[0],
+                                  pJson[pMasqueradingVector[0]], err, false))
+                return false;
+        } else {
+            err =
+                "The value of primary key must be set in the json object for "
+                "update";
+            return false;
+        }
+        if (!pMasqueradingVector[1].empty() &&
+            pJson.isMember(pMasqueradingVector[1])) {
+            if (!validJsonOfField(1, pMasqueradingVector[1],
+                                  pJson[pMasqueradingVector[1]], err, false))
+                return false;
+        } else {
+            err =
+                "The value of primary key must be set in the json object for "
+                "update";
+            return false;
+        }
+        if (!pMasqueradingVector[2].empty() &&
+            pJson.isMember(pMasqueradingVector[2])) {
+            if (!validJsonOfField(2, pMasqueradingVector[2],
+                                  pJson[pMasqueradingVector[2]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[3].empty() &&
+            pJson.isMember(pMasqueradingVector[3])) {
+            if (!validJsonOfField(3, pMasqueradingVector[3],
+                                  pJson[pMasqueradingVector[3]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[4].empty() &&
+            pJson.isMember(pMasqueradingVector[4])) {
+            if (!validJsonOfField(4, pMasqueradingVector[4],
+                                  pJson[pMasqueradingVector[4]], err, false))
+                return false;
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Players::validJsonOfField(size_t index,
+                               const std::string &fieldName,
+                               const Json::Value &pJson,
+                               std::string &err,
+                               bool isForCreation) {
+    switch (index) {
+        case 0:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 1:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 2:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isInt()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 3:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isInt()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 4:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        default:
+            err = "Internal error in the server";
+            return false;
+            break;
+    }
+    return true;
+}
+void Players::getSession(const DbClientPtr &clientPtr,
+                         const std::function<void(Sessions)> &rcb,
+                         const ExceptionCallback &ecb) const {
+    const static std::string sql = "select * from sessions where id = $1";
+    *clientPtr << sql << *sessionId_ >> [rcb = std::move(rcb),
+                                         ecb](const Result &r) {
+        if (r.size() == 0) {
+            ecb(UnexpectedRows("0 rows found"));
+        } else if (r.size() > 1) {
+            ecb(UnexpectedRows("Found more than one row"));
+        } else {
+            rcb(Sessions(r[0]));
+        }
+    } >> ecb;
+}
+void Players::getUser(const DbClientPtr &clientPtr,
+                      const std::function<void(Users)> &rcb,
+                      const ExceptionCallback &ecb) const {
+    const static std::string sql = "select * from users where id = $1";
+    *clientPtr << sql << *userId_ >> [rcb = std::move(rcb),
+                                      ecb](const Result &r) {
+        if (r.size() == 0) {
+            ecb(UnexpectedRows("0 rows found"));
+        } else if (r.size() > 1) {
+            ecb(UnexpectedRows("Found more than one row"));
+        } else {
+            rcb(Users(r[0]));
+        }
+    } >> ecb;
+}
diff --git a/server/sql-models/Players.h b/server/sql-models/Players.h
new file mode 100644
index 00000000..07f6852e
--- /dev/null
+++ b/server/sql-models/Players.h
@@ -0,0 +1,284 @@
+/**
+ *
+ *  Players.h
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#pragma once
+#include <drogon/orm/Field.h>
+#include <drogon/orm/Mapper.h>
+#include <drogon/orm/Result.h>
+#include <drogon/orm/Row.h>
+#include <drogon/orm/SqlBinder.h>
+#ifdef __cpp_impl_coroutine
+#include <drogon/orm/CoroMapper.h>
+#endif
+#include <json/json.h>
+#include <stdint.h>
+#include <trantor/utils/Date.h>
+#include <trantor/utils/Logger.h>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace drogon {
+namespace orm {
+class DbClient;
+using DbClientPtr = std::shared_ptr<DbClient>;
+}  // namespace orm
+}  // namespace drogon
+namespace drogon_model {
+namespace cavoke_orm {
+class Sessions;
+class Users;
+
+class Players {
+public:
+    struct Cols {
+        static const std::string _session_id;
+        static const std::string _user_id;
+        static const std::string _player_id;
+        static const std::string _score;
+        static const std::string _playerstate;
+    };
+
+    const static int primaryKeyNumber;
+    const static std::string tableName;
+    const static bool hasPrimaryKey;
+    const static std::vector<std::string> primaryKeyName;
+    using PrimaryKeyType =
+        std::tuple<std::string, std::string>;  // session_id,user_id
+    PrimaryKeyType getPrimaryKey() const;
+
+    /**
+     * @brief constructor
+     * @param r One row of records in the SQL query result.
+     * @param indexOffset Set the offset to -1 to access all columns by column
+     * names, otherwise access all columns by offsets.
+     * @note If the SQL is not a style of 'select * from table_name ...' (select
+     * all columns by an asterisk), please set the offset to -1.
+     */
+    explicit Players(const drogon::orm::Row &r,
+                     const ssize_t indexOffset = 0) noexcept;
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     */
+    explicit Players(const Json::Value &pJson) noexcept(false);
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     * @param pMasqueradingVector The aliases of table columns.
+     */
+    Players(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+
+    Players() = default;
+
+    void updateByJson(const Json::Value &pJson) noexcept(false);
+    void updateByMasqueradedJson(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+    static bool validateJsonForCreation(const Json::Value &pJson,
+                                        std::string &err);
+    static bool validateMasqueradedJsonForCreation(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validateJsonForUpdate(const Json::Value &pJson,
+                                      std::string &err);
+    static bool validateMasqueradedJsonForUpdate(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validJsonOfField(size_t index,
+                                 const std::string &fieldName,
+                                 const Json::Value &pJson,
+                                 std::string &err,
+                                 bool isForCreation);
+
+    /**  For column session_id  */
+    /// Get the value of the column session_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfSessionId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getSessionId() const noexcept;
+    /// Set the value of the column session_id
+    void setSessionId(const std::string &pSessionId) noexcept;
+    void setSessionId(std::string &&pSessionId) noexcept;
+
+    /**  For column user_id  */
+    /// Get the value of the column user_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfUserId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getUserId() const noexcept;
+    /// Set the value of the column user_id
+    void setUserId(const std::string &pUserId) noexcept;
+    void setUserId(std::string &&pUserId) noexcept;
+
+    /**  For column player_id  */
+    /// Get the value of the column player_id, returns the default value if the
+    /// column is null
+    const int32_t &getValueOfPlayerId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<int32_t> &getPlayerId() const noexcept;
+    /// Set the value of the column player_id
+    void setPlayerId(const int32_t &pPlayerId) noexcept;
+
+    /**  For column score  */
+    /// Get the value of the column score, returns the default value if the
+    /// column is null
+    const int32_t &getValueOfScore() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<int32_t> &getScore() const noexcept;
+    /// Set the value of the column score
+    void setScore(const int32_t &pScore) noexcept;
+    void setScoreToNull() noexcept;
+
+    /**  For column playerstate  */
+    /// Get the value of the column playerstate, returns the default value if
+    /// the column is null
+    const std::string &getValueOfPlayerstate() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getPlayerstate() const noexcept;
+    /// Set the value of the column playerstate
+    void setPlayerstate(const std::string &pPlayerstate) noexcept;
+    void setPlayerstate(std::string &&pPlayerstate) noexcept;
+
+    static size_t getColumnNumber() noexcept {
+        return 5;
+    }
+    static const std::string &getColumnName(size_t index) noexcept(false);
+
+    Json::Value toJson() const;
+    Json::Value toMasqueradedJson(
+        const std::vector<std::string> &pMasqueradingVector) const;
+    /// Relationship interfaces
+    void getSession(const drogon::orm::DbClientPtr &clientPtr,
+                    const std::function<void(Sessions)> &rcb,
+                    const drogon::orm::ExceptionCallback &ecb) const;
+    void getUser(const drogon::orm::DbClientPtr &clientPtr,
+                 const std::function<void(Users)> &rcb,
+                 const drogon::orm::ExceptionCallback &ecb) const;
+
+private:
+    friend drogon::orm::Mapper<Players>;
+#ifdef __cpp_impl_coroutine
+    friend drogon::orm::CoroMapper<Players>;
+#endif
+    static const std::vector<std::string> &insertColumns() noexcept;
+    void outputArgs(drogon::orm::internal::SqlBinder &binder) const;
+    const std::vector<std::string> updateColumns() const;
+    void updateArgs(drogon::orm::internal::SqlBinder &binder) const;
+    /// For mysql or sqlite3
+    void updateId(const uint64_t id);
+    std::shared_ptr<std::string> sessionId_;
+    std::shared_ptr<std::string> userId_;
+    std::shared_ptr<int32_t> playerId_;
+    std::shared_ptr<int32_t> score_;
+    std::shared_ptr<std::string> playerstate_;
+    struct MetaData {
+        const std::string colName_;
+        const std::string colType_;
+        const std::string colDatabaseType_;
+        const ssize_t colLength_;
+        const bool isAutoVal_;
+        const bool isPrimaryKey_;
+        const bool notNull_;
+    };
+    static const std::vector<MetaData> metaData_;
+    bool dirtyFlag_[5] = {false};
+
+public:
+    static const std::string &sqlForFindingByPrimaryKey() {
+        static const std::string sql =
+            "select * from " + tableName +
+            " where session_id = $1 and user_id = $2";
+        return sql;
+    }
+
+    static const std::string &sqlForDeletingByPrimaryKey() {
+        static const std::string sql =
+            "delete from " + tableName +
+            " where session_id = $1 and user_id = $2";
+        return sql;
+    }
+    std::string sqlForInserting(bool &needSelection) const {
+        std::string sql = "insert into " + tableName + " (";
+        size_t parametersCount = 0;
+        needSelection = false;
+        if (dirtyFlag_[0]) {
+            sql += "session_id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[1]) {
+            sql += "user_id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[2]) {
+            sql += "player_id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[3]) {
+            sql += "score,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[4]) {
+            sql += "playerstate,";
+            ++parametersCount;
+        }
+        if (parametersCount > 0) {
+            sql[sql.length() - 1] = ')';
+            sql += " values (";
+        } else
+            sql += ") values (";
+
+        int placeholder = 1;
+        char placeholderStr[64];
+        size_t n = 0;
+        if (dirtyFlag_[0]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[1]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[2]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[3]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[4]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (parametersCount > 0) {
+            sql.resize(sql.length() - 1);
+        }
+        if (needSelection) {
+            sql.append(") returning *");
+        } else {
+            sql.append(1, ')');
+        }
+        LOG_TRACE << sql;
+        return sql;
+    }
+};
+}  // namespace cavoke_orm
+}  // namespace drogon_model
diff --git a/server/sql-models/RoomJoins.cc b/server/sql-models/RoomJoins.cc
new file mode 100644
index 00000000..c382f9ba
--- /dev/null
+++ b/server/sql-models/RoomJoins.cc
@@ -0,0 +1,456 @@
+/**
+ *
+ *  RoomJoins.cc
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#include "RoomJoins.h"
+#include <drogon/utils/Utilities.h>
+#include <string>
+#include "Rooms.h"
+#include "Users.h"
+
+using namespace drogon;
+using namespace drogon::orm;
+using namespace drogon_model::cavoke_orm;
+
+const std::string RoomJoins::Cols::_room_id = "room_id";
+const std::string RoomJoins::Cols::_user_id = "user_id";
+const std::vector<std::string> RoomJoins::primaryKeyName = {"room_id",
+                                                            "user_id"};
+const bool RoomJoins::hasPrimaryKey = true;
+const std::string RoomJoins::tableName = "room_joins";
+
+const std::vector<typename RoomJoins::MetaData> RoomJoins::metaData_ = {
+    {"room_id", "std::string", "uuid", 0, 0, 1, 1},
+    {"user_id", "std::string", "character varying", 0, 0, 1, 1}};
+const std::string &RoomJoins::getColumnName(size_t index) noexcept(false) {
+    assert(index < metaData_.size());
+    return metaData_[index].colName_;
+}
+RoomJoins::RoomJoins(const Row &r, const ssize_t indexOffset) noexcept {
+    if (indexOffset < 0) {
+        if (!r["room_id"].isNull()) {
+            roomId_ =
+                std::make_shared<std::string>(r["room_id"].as<std::string>());
+        }
+        if (!r["user_id"].isNull()) {
+            userId_ =
+                std::make_shared<std::string>(r["user_id"].as<std::string>());
+        }
+    } else {
+        size_t offset = (size_t)indexOffset;
+        if (offset + 2 > r.size()) {
+            LOG_FATAL << "Invalid SQL result for this model";
+            return;
+        }
+        size_t index;
+        index = offset + 0;
+        if (!r[index].isNull()) {
+            roomId_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 1;
+        if (!r[index].isNull()) {
+            userId_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+    }
+}
+
+RoomJoins::RoomJoins(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 2) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        dirtyFlag_[0] = true;
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            roomId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            userId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+}
+
+RoomJoins::RoomJoins(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("room_id")) {
+        dirtyFlag_[0] = true;
+        if (!pJson["room_id"].isNull()) {
+            roomId_ =
+                std::make_shared<std::string>(pJson["room_id"].asString());
+        }
+    }
+    if (pJson.isMember("user_id")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["user_id"].isNull()) {
+            userId_ =
+                std::make_shared<std::string>(pJson["user_id"].asString());
+        }
+    }
+}
+
+void RoomJoins::updateByMasqueradedJson(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 2) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            roomId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            userId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+}
+
+void RoomJoins::updateByJson(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("room_id")) {
+        if (!pJson["room_id"].isNull()) {
+            roomId_ =
+                std::make_shared<std::string>(pJson["room_id"].asString());
+        }
+    }
+    if (pJson.isMember("user_id")) {
+        if (!pJson["user_id"].isNull()) {
+            userId_ =
+                std::make_shared<std::string>(pJson["user_id"].asString());
+        }
+    }
+}
+
+const std::string &RoomJoins::getValueOfRoomId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (roomId_)
+        return *roomId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &RoomJoins::getRoomId() const noexcept {
+    return roomId_;
+}
+void RoomJoins::setRoomId(const std::string &pRoomId) noexcept {
+    roomId_ = std::make_shared<std::string>(pRoomId);
+    dirtyFlag_[0] = true;
+}
+void RoomJoins::setRoomId(std::string &&pRoomId) noexcept {
+    roomId_ = std::make_shared<std::string>(std::move(pRoomId));
+    dirtyFlag_[0] = true;
+}
+
+const std::string &RoomJoins::getValueOfUserId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (userId_)
+        return *userId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &RoomJoins::getUserId() const noexcept {
+    return userId_;
+}
+void RoomJoins::setUserId(const std::string &pUserId) noexcept {
+    userId_ = std::make_shared<std::string>(pUserId);
+    dirtyFlag_[1] = true;
+}
+void RoomJoins::setUserId(std::string &&pUserId) noexcept {
+    userId_ = std::make_shared<std::string>(std::move(pUserId));
+    dirtyFlag_[1] = true;
+}
+
+void RoomJoins::updateId(const uint64_t id) {
+}
+typename RoomJoins::PrimaryKeyType RoomJoins::getPrimaryKey() const {
+    return std::make_tuple(*roomId_, *userId_);
+}
+
+const std::vector<std::string> &RoomJoins::insertColumns() noexcept {
+    static const std::vector<std::string> inCols = {"room_id", "user_id"};
+    return inCols;
+}
+
+void RoomJoins::outputArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getRoomId()) {
+            binder << getValueOfRoomId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getUserId()) {
+            binder << getValueOfUserId();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+
+const std::vector<std::string> RoomJoins::updateColumns() const {
+    std::vector<std::string> ret;
+    if (dirtyFlag_[0]) {
+        ret.push_back(getColumnName(0));
+    }
+    if (dirtyFlag_[1]) {
+        ret.push_back(getColumnName(1));
+    }
+    return ret;
+}
+
+void RoomJoins::updateArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getRoomId()) {
+            binder << getValueOfRoomId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getUserId()) {
+            binder << getValueOfUserId();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+Json::Value RoomJoins::toJson() const {
+    Json::Value ret;
+    if (getRoomId()) {
+        ret["room_id"] = getValueOfRoomId();
+    } else {
+        ret["room_id"] = Json::Value();
+    }
+    if (getUserId()) {
+        ret["user_id"] = getValueOfUserId();
+    } else {
+        ret["user_id"] = Json::Value();
+    }
+    return ret;
+}
+
+Json::Value RoomJoins::toMasqueradedJson(
+    const std::vector<std::string> &pMasqueradingVector) const {
+    Json::Value ret;
+    if (pMasqueradingVector.size() == 2) {
+        if (!pMasqueradingVector[0].empty()) {
+            if (getRoomId()) {
+                ret[pMasqueradingVector[0]] = getValueOfRoomId();
+            } else {
+                ret[pMasqueradingVector[0]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (getUserId()) {
+                ret[pMasqueradingVector[1]] = getValueOfUserId();
+            } else {
+                ret[pMasqueradingVector[1]] = Json::Value();
+            }
+        }
+        return ret;
+    }
+    LOG_ERROR << "Masquerade failed";
+    if (getRoomId()) {
+        ret["room_id"] = getValueOfRoomId();
+    } else {
+        ret["room_id"] = Json::Value();
+    }
+    if (getUserId()) {
+        ret["user_id"] = getValueOfUserId();
+    } else {
+        ret["user_id"] = Json::Value();
+    }
+    return ret;
+}
+
+bool RoomJoins::validateJsonForCreation(const Json::Value &pJson,
+                                        std::string &err) {
+    if (pJson.isMember("room_id")) {
+        if (!validJsonOfField(0, "room_id", pJson["room_id"], err, true))
+            return false;
+    } else {
+        err = "The room_id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("user_id")) {
+        if (!validJsonOfField(1, "user_id", pJson["user_id"], err, true))
+            return false;
+    } else {
+        err = "The user_id column cannot be null";
+        return false;
+    }
+    return true;
+}
+bool RoomJoins::validateMasqueradedJsonForCreation(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 2) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty()) {
+            if (pJson.isMember(pMasqueradingVector[0])) {
+                if (!validJsonOfField(0, pMasqueradingVector[0],
+                                      pJson[pMasqueradingVector[0]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[0] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (pJson.isMember(pMasqueradingVector[1])) {
+                if (!validJsonOfField(1, pMasqueradingVector[1],
+                                      pJson[pMasqueradingVector[1]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[1] + " column cannot be null";
+                return false;
+            }
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool RoomJoins::validateJsonForUpdate(const Json::Value &pJson,
+                                      std::string &err) {
+    if (pJson.isMember("room_id")) {
+        if (!validJsonOfField(0, "room_id", pJson["room_id"], err, false))
+            return false;
+    } else {
+        err =
+            "The value of primary key must be set in the json object for "
+            "update";
+        return false;
+    }
+    if (pJson.isMember("user_id")) {
+        if (!validJsonOfField(1, "user_id", pJson["user_id"], err, false))
+            return false;
+    } else {
+        err =
+            "The value of primary key must be set in the json object for "
+            "update";
+        return false;
+    }
+    return true;
+}
+bool RoomJoins::validateMasqueradedJsonForUpdate(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 2) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty() &&
+            pJson.isMember(pMasqueradingVector[0])) {
+            if (!validJsonOfField(0, pMasqueradingVector[0],
+                                  pJson[pMasqueradingVector[0]], err, false))
+                return false;
+        } else {
+            err =
+                "The value of primary key must be set in the json object for "
+                "update";
+            return false;
+        }
+        if (!pMasqueradingVector[1].empty() &&
+            pJson.isMember(pMasqueradingVector[1])) {
+            if (!validJsonOfField(1, pMasqueradingVector[1],
+                                  pJson[pMasqueradingVector[1]], err, false))
+                return false;
+        } else {
+            err =
+                "The value of primary key must be set in the json object for "
+                "update";
+            return false;
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool RoomJoins::validJsonOfField(size_t index,
+                                 const std::string &fieldName,
+                                 const Json::Value &pJson,
+                                 std::string &err,
+                                 bool isForCreation) {
+    switch (index) {
+        case 0:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 1:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        default:
+            err = "Internal error in the server";
+            return false;
+            break;
+    }
+    return true;
+}
+void RoomJoins::getRoom(const DbClientPtr &clientPtr,
+                        const std::function<void(Rooms)> &rcb,
+                        const ExceptionCallback &ecb) const {
+    const static std::string sql = "select * from rooms where id = $1";
+    *clientPtr << sql << *roomId_ >> [rcb = std::move(rcb),
+                                      ecb](const Result &r) {
+        if (r.size() == 0) {
+            ecb(UnexpectedRows("0 rows found"));
+        } else if (r.size() > 1) {
+            ecb(UnexpectedRows("Found more than one row"));
+        } else {
+            rcb(Rooms(r[0]));
+        }
+    } >> ecb;
+}
+void RoomJoins::getUser(const DbClientPtr &clientPtr,
+                        const std::function<void(Users)> &rcb,
+                        const ExceptionCallback &ecb) const {
+    const static std::string sql = "select * from users where id = $1";
+    *clientPtr << sql << *userId_ >> [rcb = std::move(rcb),
+                                      ecb](const Result &r) {
+        if (r.size() == 0) {
+            ecb(UnexpectedRows("0 rows found"));
+        } else if (r.size() > 1) {
+            ecb(UnexpectedRows("Found more than one row"));
+        } else {
+            rcb(Users(r[0]));
+        }
+    } >> ecb;
+}
diff --git a/server/sql-models/RoomJoins.h b/server/sql-models/RoomJoins.h
new file mode 100644
index 00000000..5fed2401
--- /dev/null
+++ b/server/sql-models/RoomJoins.h
@@ -0,0 +1,220 @@
+/**
+ *
+ *  RoomJoins.h
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#pragma once
+#include <drogon/orm/Field.h>
+#include <drogon/orm/Mapper.h>
+#include <drogon/orm/Result.h>
+#include <drogon/orm/Row.h>
+#include <drogon/orm/SqlBinder.h>
+#ifdef __cpp_impl_coroutine
+#include <drogon/orm/CoroMapper.h>
+#endif
+#include <json/json.h>
+#include <stdint.h>
+#include <trantor/utils/Date.h>
+#include <trantor/utils/Logger.h>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace drogon {
+namespace orm {
+class DbClient;
+using DbClientPtr = std::shared_ptr<DbClient>;
+}  // namespace orm
+}  // namespace drogon
+namespace drogon_model {
+namespace cavoke_orm {
+class Rooms;
+class Users;
+
+class RoomJoins {
+public:
+    struct Cols {
+        static const std::string _room_id;
+        static const std::string _user_id;
+    };
+
+    const static int primaryKeyNumber;
+    const static std::string tableName;
+    const static bool hasPrimaryKey;
+    const static std::vector<std::string> primaryKeyName;
+    using PrimaryKeyType =
+        std::tuple<std::string, std::string>;  // room_id,user_id
+    PrimaryKeyType getPrimaryKey() const;
+
+    /**
+     * @brief constructor
+     * @param r One row of records in the SQL query result.
+     * @param indexOffset Set the offset to -1 to access all columns by column
+     * names, otherwise access all columns by offsets.
+     * @note If the SQL is not a style of 'select * from table_name ...' (select
+     * all columns by an asterisk), please set the offset to -1.
+     */
+    explicit RoomJoins(const drogon::orm::Row &r,
+                       const ssize_t indexOffset = 0) noexcept;
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     */
+    explicit RoomJoins(const Json::Value &pJson) noexcept(false);
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     * @param pMasqueradingVector The aliases of table columns.
+     */
+    RoomJoins(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+
+    RoomJoins() = default;
+
+    void updateByJson(const Json::Value &pJson) noexcept(false);
+    void updateByMasqueradedJson(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+    static bool validateJsonForCreation(const Json::Value &pJson,
+                                        std::string &err);
+    static bool validateMasqueradedJsonForCreation(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validateJsonForUpdate(const Json::Value &pJson,
+                                      std::string &err);
+    static bool validateMasqueradedJsonForUpdate(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validJsonOfField(size_t index,
+                                 const std::string &fieldName,
+                                 const Json::Value &pJson,
+                                 std::string &err,
+                                 bool isForCreation);
+
+    /**  For column room_id  */
+    /// Get the value of the column room_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfRoomId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getRoomId() const noexcept;
+    /// Set the value of the column room_id
+    void setRoomId(const std::string &pRoomId) noexcept;
+    void setRoomId(std::string &&pRoomId) noexcept;
+
+    /**  For column user_id  */
+    /// Get the value of the column user_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfUserId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getUserId() const noexcept;
+    /// Set the value of the column user_id
+    void setUserId(const std::string &pUserId) noexcept;
+    void setUserId(std::string &&pUserId) noexcept;
+
+    static size_t getColumnNumber() noexcept {
+        return 2;
+    }
+    static const std::string &getColumnName(size_t index) noexcept(false);
+
+    Json::Value toJson() const;
+    Json::Value toMasqueradedJson(
+        const std::vector<std::string> &pMasqueradingVector) const;
+    /// Relationship interfaces
+    void getRoom(const drogon::orm::DbClientPtr &clientPtr,
+                 const std::function<void(Rooms)> &rcb,
+                 const drogon::orm::ExceptionCallback &ecb) const;
+    void getUser(const drogon::orm::DbClientPtr &clientPtr,
+                 const std::function<void(Users)> &rcb,
+                 const drogon::orm::ExceptionCallback &ecb) const;
+
+private:
+    friend drogon::orm::Mapper<RoomJoins>;
+#ifdef __cpp_impl_coroutine
+    friend drogon::orm::CoroMapper<RoomJoins>;
+#endif
+    static const std::vector<std::string> &insertColumns() noexcept;
+    void outputArgs(drogon::orm::internal::SqlBinder &binder) const;
+    const std::vector<std::string> updateColumns() const;
+    void updateArgs(drogon::orm::internal::SqlBinder &binder) const;
+    /// For mysql or sqlite3
+    void updateId(const uint64_t id);
+    std::shared_ptr<std::string> roomId_;
+    std::shared_ptr<std::string> userId_;
+    struct MetaData {
+        const std::string colName_;
+        const std::string colType_;
+        const std::string colDatabaseType_;
+        const ssize_t colLength_;
+        const bool isAutoVal_;
+        const bool isPrimaryKey_;
+        const bool notNull_;
+    };
+    static const std::vector<MetaData> metaData_;
+    bool dirtyFlag_[2] = {false};
+
+public:
+    static const std::string &sqlForFindingByPrimaryKey() {
+        static const std::string sql = "select * from " + tableName +
+                                       " where room_id = $1 and user_id = $2";
+        return sql;
+    }
+
+    static const std::string &sqlForDeletingByPrimaryKey() {
+        static const std::string sql =
+            "delete from " + tableName + " where room_id = $1 and user_id = $2";
+        return sql;
+    }
+    std::string sqlForInserting(bool &needSelection) const {
+        std::string sql = "insert into " + tableName + " (";
+        size_t parametersCount = 0;
+        needSelection = false;
+        if (dirtyFlag_[0]) {
+            sql += "room_id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[1]) {
+            sql += "user_id,";
+            ++parametersCount;
+        }
+        if (parametersCount > 0) {
+            sql[sql.length() - 1] = ')';
+            sql += " values (";
+        } else
+            sql += ") values (";
+
+        int placeholder = 1;
+        char placeholderStr[64];
+        size_t n = 0;
+        if (dirtyFlag_[0]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[1]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (parametersCount > 0) {
+            sql.resize(sql.length() - 1);
+        }
+        if (needSelection) {
+            sql.append(") returning *");
+        } else {
+            sql.append(1, ')');
+        }
+        LOG_TRACE << sql;
+        return sql;
+    }
+};
+}  // namespace cavoke_orm
+}  // namespace drogon_model
diff --git a/server/sql-models/Rooms.cc b/server/sql-models/Rooms.cc
new file mode 100644
index 00000000..38245529
--- /dev/null
+++ b/server/sql-models/Rooms.cc
@@ -0,0 +1,817 @@
+/**
+ *
+ *  Rooms.cc
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#include "Rooms.h"
+#include <drogon/utils/Utilities.h>
+#include <string>
+#include "RoomJoins.h"
+
+using namespace drogon;
+using namespace drogon::orm;
+using namespace drogon_model::cavoke_orm;
+
+const std::string Rooms::Cols::_id = "id";
+const std::string Rooms::Cols::_display_name = "display_name";
+const std::string Rooms::Cols::_invite_code = "invite_code";
+const std::string Rooms::Cols::_host_id = "host_id";
+const std::string Rooms::Cols::_session_id = "session_id";
+const std::string Rooms::primaryKeyName = "id";
+const bool Rooms::hasPrimaryKey = true;
+const std::string Rooms::tableName = "rooms";
+
+const std::vector<typename Rooms::MetaData> Rooms::metaData_ = {
+    {"id", "std::string", "uuid", 0, 0, 1, 1},
+    {"display_name", "std::string", "character varying", 0, 0, 0, 1},
+    {"invite_code", "std::string", "character varying", 0, 0, 0, 1},
+    {"host_id", "std::string", "character varying", 0, 0, 0, 0},
+    {"session_id", "std::string", "uuid", 0, 0, 0, 0}};
+const std::string &Rooms::getColumnName(size_t index) noexcept(false) {
+    assert(index < metaData_.size());
+    return metaData_[index].colName_;
+}
+Rooms::Rooms(const Row &r, const ssize_t indexOffset) noexcept {
+    if (indexOffset < 0) {
+        if (!r["id"].isNull()) {
+            id_ = std::make_shared<std::string>(r["id"].as<std::string>());
+        }
+        if (!r["display_name"].isNull()) {
+            displayName_ = std::make_shared<std::string>(
+                r["display_name"].as<std::string>());
+        }
+        if (!r["invite_code"].isNull()) {
+            inviteCode_ = std::make_shared<std::string>(
+                r["invite_code"].as<std::string>());
+        }
+        if (!r["host_id"].isNull()) {
+            hostId_ =
+                std::make_shared<std::string>(r["host_id"].as<std::string>());
+        }
+        if (!r["session_id"].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                r["session_id"].as<std::string>());
+        }
+    } else {
+        size_t offset = (size_t)indexOffset;
+        if (offset + 5 > r.size()) {
+            LOG_FATAL << "Invalid SQL result for this model";
+            return;
+        }
+        size_t index;
+        index = offset + 0;
+        if (!r[index].isNull()) {
+            id_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 1;
+        if (!r[index].isNull()) {
+            displayName_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 2;
+        if (!r[index].isNull()) {
+            inviteCode_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 3;
+        if (!r[index].isNull()) {
+            hostId_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 4;
+        if (!r[index].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+    }
+}
+
+Rooms::Rooms(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 5) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        dirtyFlag_[0] = true;
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            id_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            displayName_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            inviteCode_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[2]].asString());
+        }
+    }
+    if (!pMasqueradingVector[3].empty() &&
+        pJson.isMember(pMasqueradingVector[3])) {
+        dirtyFlag_[3] = true;
+        if (!pJson[pMasqueradingVector[3]].isNull()) {
+            hostId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[3]].asString());
+        }
+    }
+    if (!pMasqueradingVector[4].empty() &&
+        pJson.isMember(pMasqueradingVector[4])) {
+        dirtyFlag_[4] = true;
+        if (!pJson[pMasqueradingVector[4]].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[4]].asString());
+        }
+    }
+}
+
+Rooms::Rooms(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("id")) {
+        dirtyFlag_[0] = true;
+        if (!pJson["id"].isNull()) {
+            id_ = std::make_shared<std::string>(pJson["id"].asString());
+        }
+    }
+    if (pJson.isMember("display_name")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["display_name"].isNull()) {
+            displayName_ =
+                std::make_shared<std::string>(pJson["display_name"].asString());
+        }
+    }
+    if (pJson.isMember("invite_code")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["invite_code"].isNull()) {
+            inviteCode_ =
+                std::make_shared<std::string>(pJson["invite_code"].asString());
+        }
+    }
+    if (pJson.isMember("host_id")) {
+        dirtyFlag_[3] = true;
+        if (!pJson["host_id"].isNull()) {
+            hostId_ =
+                std::make_shared<std::string>(pJson["host_id"].asString());
+        }
+    }
+    if (pJson.isMember("session_id")) {
+        dirtyFlag_[4] = true;
+        if (!pJson["session_id"].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(pJson["session_id"].asString());
+        }
+    }
+}
+
+void Rooms::updateByMasqueradedJson(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 5) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            id_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            displayName_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            inviteCode_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[2]].asString());
+        }
+    }
+    if (!pMasqueradingVector[3].empty() &&
+        pJson.isMember(pMasqueradingVector[3])) {
+        dirtyFlag_[3] = true;
+        if (!pJson[pMasqueradingVector[3]].isNull()) {
+            hostId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[3]].asString());
+        }
+    }
+    if (!pMasqueradingVector[4].empty() &&
+        pJson.isMember(pMasqueradingVector[4])) {
+        dirtyFlag_[4] = true;
+        if (!pJson[pMasqueradingVector[4]].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[4]].asString());
+        }
+    }
+}
+
+void Rooms::updateByJson(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("id")) {
+        if (!pJson["id"].isNull()) {
+            id_ = std::make_shared<std::string>(pJson["id"].asString());
+        }
+    }
+    if (pJson.isMember("display_name")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["display_name"].isNull()) {
+            displayName_ =
+                std::make_shared<std::string>(pJson["display_name"].asString());
+        }
+    }
+    if (pJson.isMember("invite_code")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["invite_code"].isNull()) {
+            inviteCode_ =
+                std::make_shared<std::string>(pJson["invite_code"].asString());
+        }
+    }
+    if (pJson.isMember("host_id")) {
+        dirtyFlag_[3] = true;
+        if (!pJson["host_id"].isNull()) {
+            hostId_ =
+                std::make_shared<std::string>(pJson["host_id"].asString());
+        }
+    }
+    if (pJson.isMember("session_id")) {
+        dirtyFlag_[4] = true;
+        if (!pJson["session_id"].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(pJson["session_id"].asString());
+        }
+    }
+}
+
+const std::string &Rooms::getValueOfId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (id_)
+        return *id_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Rooms::getId() const noexcept {
+    return id_;
+}
+void Rooms::setId(const std::string &pId) noexcept {
+    id_ = std::make_shared<std::string>(pId);
+    dirtyFlag_[0] = true;
+}
+void Rooms::setId(std::string &&pId) noexcept {
+    id_ = std::make_shared<std::string>(std::move(pId));
+    dirtyFlag_[0] = true;
+}
+const typename Rooms::PrimaryKeyType &Rooms::getPrimaryKey() const {
+    assert(id_);
+    return *id_;
+}
+
+const std::string &Rooms::getValueOfDisplayName() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (displayName_)
+        return *displayName_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Rooms::getDisplayName() const noexcept {
+    return displayName_;
+}
+void Rooms::setDisplayName(const std::string &pDisplayName) noexcept {
+    displayName_ = std::make_shared<std::string>(pDisplayName);
+    dirtyFlag_[1] = true;
+}
+void Rooms::setDisplayName(std::string &&pDisplayName) noexcept {
+    displayName_ = std::make_shared<std::string>(std::move(pDisplayName));
+    dirtyFlag_[1] = true;
+}
+
+const std::string &Rooms::getValueOfInviteCode() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (inviteCode_)
+        return *inviteCode_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Rooms::getInviteCode() const noexcept {
+    return inviteCode_;
+}
+void Rooms::setInviteCode(const std::string &pInviteCode) noexcept {
+    inviteCode_ = std::make_shared<std::string>(pInviteCode);
+    dirtyFlag_[2] = true;
+}
+void Rooms::setInviteCode(std::string &&pInviteCode) noexcept {
+    inviteCode_ = std::make_shared<std::string>(std::move(pInviteCode));
+    dirtyFlag_[2] = true;
+}
+
+const std::string &Rooms::getValueOfHostId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (hostId_)
+        return *hostId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Rooms::getHostId() const noexcept {
+    return hostId_;
+}
+void Rooms::setHostId(const std::string &pHostId) noexcept {
+    hostId_ = std::make_shared<std::string>(pHostId);
+    dirtyFlag_[3] = true;
+}
+void Rooms::setHostId(std::string &&pHostId) noexcept {
+    hostId_ = std::make_shared<std::string>(std::move(pHostId));
+    dirtyFlag_[3] = true;
+}
+void Rooms::setHostIdToNull() noexcept {
+    hostId_.reset();
+    dirtyFlag_[3] = true;
+}
+
+const std::string &Rooms::getValueOfSessionId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (sessionId_)
+        return *sessionId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Rooms::getSessionId() const noexcept {
+    return sessionId_;
+}
+void Rooms::setSessionId(const std::string &pSessionId) noexcept {
+    sessionId_ = std::make_shared<std::string>(pSessionId);
+    dirtyFlag_[4] = true;
+}
+void Rooms::setSessionId(std::string &&pSessionId) noexcept {
+    sessionId_ = std::make_shared<std::string>(std::move(pSessionId));
+    dirtyFlag_[4] = true;
+}
+void Rooms::setSessionIdToNull() noexcept {
+    sessionId_.reset();
+    dirtyFlag_[4] = true;
+}
+
+void Rooms::updateId(const uint64_t id) {
+}
+
+const std::vector<std::string> &Rooms::insertColumns() noexcept {
+    static const std::vector<std::string> inCols = {
+        "id", "display_name", "invite_code", "host_id", "session_id"};
+    return inCols;
+}
+
+void Rooms::outputArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getId()) {
+            binder << getValueOfId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getDisplayName()) {
+            binder << getValueOfDisplayName();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getInviteCode()) {
+            binder << getValueOfInviteCode();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[3]) {
+        if (getHostId()) {
+            binder << getValueOfHostId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[4]) {
+        if (getSessionId()) {
+            binder << getValueOfSessionId();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+
+const std::vector<std::string> Rooms::updateColumns() const {
+    std::vector<std::string> ret;
+    if (dirtyFlag_[0]) {
+        ret.push_back(getColumnName(0));
+    }
+    if (dirtyFlag_[1]) {
+        ret.push_back(getColumnName(1));
+    }
+    if (dirtyFlag_[2]) {
+        ret.push_back(getColumnName(2));
+    }
+    if (dirtyFlag_[3]) {
+        ret.push_back(getColumnName(3));
+    }
+    if (dirtyFlag_[4]) {
+        ret.push_back(getColumnName(4));
+    }
+    return ret;
+}
+
+void Rooms::updateArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getId()) {
+            binder << getValueOfId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getDisplayName()) {
+            binder << getValueOfDisplayName();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getInviteCode()) {
+            binder << getValueOfInviteCode();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[3]) {
+        if (getHostId()) {
+            binder << getValueOfHostId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[4]) {
+        if (getSessionId()) {
+            binder << getValueOfSessionId();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+Json::Value Rooms::toJson() const {
+    Json::Value ret;
+    if (getId()) {
+        ret["id"] = getValueOfId();
+    } else {
+        ret["id"] = Json::Value();
+    }
+    if (getDisplayName()) {
+        ret["display_name"] = getValueOfDisplayName();
+    } else {
+        ret["display_name"] = Json::Value();
+    }
+    if (getInviteCode()) {
+        ret["invite_code"] = getValueOfInviteCode();
+    } else {
+        ret["invite_code"] = Json::Value();
+    }
+    if (getHostId()) {
+        ret["host_id"] = getValueOfHostId();
+    } else {
+        ret["host_id"] = Json::Value();
+    }
+    if (getSessionId()) {
+        ret["session_id"] = getValueOfSessionId();
+    } else {
+        ret["session_id"] = Json::Value();
+    }
+    return ret;
+}
+
+Json::Value Rooms::toMasqueradedJson(
+    const std::vector<std::string> &pMasqueradingVector) const {
+    Json::Value ret;
+    if (pMasqueradingVector.size() == 5) {
+        if (!pMasqueradingVector[0].empty()) {
+            if (getId()) {
+                ret[pMasqueradingVector[0]] = getValueOfId();
+            } else {
+                ret[pMasqueradingVector[0]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (getDisplayName()) {
+                ret[pMasqueradingVector[1]] = getValueOfDisplayName();
+            } else {
+                ret[pMasqueradingVector[1]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (getInviteCode()) {
+                ret[pMasqueradingVector[2]] = getValueOfInviteCode();
+            } else {
+                ret[pMasqueradingVector[2]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[3].empty()) {
+            if (getHostId()) {
+                ret[pMasqueradingVector[3]] = getValueOfHostId();
+            } else {
+                ret[pMasqueradingVector[3]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[4].empty()) {
+            if (getSessionId()) {
+                ret[pMasqueradingVector[4]] = getValueOfSessionId();
+            } else {
+                ret[pMasqueradingVector[4]] = Json::Value();
+            }
+        }
+        return ret;
+    }
+    LOG_ERROR << "Masquerade failed";
+    if (getId()) {
+        ret["id"] = getValueOfId();
+    } else {
+        ret["id"] = Json::Value();
+    }
+    if (getDisplayName()) {
+        ret["display_name"] = getValueOfDisplayName();
+    } else {
+        ret["display_name"] = Json::Value();
+    }
+    if (getInviteCode()) {
+        ret["invite_code"] = getValueOfInviteCode();
+    } else {
+        ret["invite_code"] = Json::Value();
+    }
+    if (getHostId()) {
+        ret["host_id"] = getValueOfHostId();
+    } else {
+        ret["host_id"] = Json::Value();
+    }
+    if (getSessionId()) {
+        ret["session_id"] = getValueOfSessionId();
+    } else {
+        ret["session_id"] = Json::Value();
+    }
+    return ret;
+}
+
+bool Rooms::validateJsonForCreation(const Json::Value &pJson,
+                                    std::string &err) {
+    if (pJson.isMember("id")) {
+        if (!validJsonOfField(0, "id", pJson["id"], err, true))
+            return false;
+    } else {
+        err = "The id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("display_name")) {
+        if (!validJsonOfField(1, "display_name", pJson["display_name"], err,
+                              true))
+            return false;
+    } else {
+        err = "The display_name column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("invite_code")) {
+        if (!validJsonOfField(2, "invite_code", pJson["invite_code"], err,
+                              true))
+            return false;
+    } else {
+        err = "The invite_code column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("host_id")) {
+        if (!validJsonOfField(3, "host_id", pJson["host_id"], err, true))
+            return false;
+    }
+    if (pJson.isMember("session_id")) {
+        if (!validJsonOfField(4, "session_id", pJson["session_id"], err, true))
+            return false;
+    }
+    return true;
+}
+bool Rooms::validateMasqueradedJsonForCreation(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 5) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty()) {
+            if (pJson.isMember(pMasqueradingVector[0])) {
+                if (!validJsonOfField(0, pMasqueradingVector[0],
+                                      pJson[pMasqueradingVector[0]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[0] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (pJson.isMember(pMasqueradingVector[1])) {
+                if (!validJsonOfField(1, pMasqueradingVector[1],
+                                      pJson[pMasqueradingVector[1]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[1] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (pJson.isMember(pMasqueradingVector[2])) {
+                if (!validJsonOfField(2, pMasqueradingVector[2],
+                                      pJson[pMasqueradingVector[2]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[2] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[3].empty()) {
+            if (pJson.isMember(pMasqueradingVector[3])) {
+                if (!validJsonOfField(3, pMasqueradingVector[3],
+                                      pJson[pMasqueradingVector[3]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[4].empty()) {
+            if (pJson.isMember(pMasqueradingVector[4])) {
+                if (!validJsonOfField(4, pMasqueradingVector[4],
+                                      pJson[pMasqueradingVector[4]], err, true))
+                    return false;
+            }
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Rooms::validateJsonForUpdate(const Json::Value &pJson, std::string &err) {
+    if (pJson.isMember("id")) {
+        if (!validJsonOfField(0, "id", pJson["id"], err, false))
+            return false;
+    } else {
+        err =
+            "The value of primary key must be set in the json object for "
+            "update";
+        return false;
+    }
+    if (pJson.isMember("display_name")) {
+        if (!validJsonOfField(1, "display_name", pJson["display_name"], err,
+                              false))
+            return false;
+    }
+    if (pJson.isMember("invite_code")) {
+        if (!validJsonOfField(2, "invite_code", pJson["invite_code"], err,
+                              false))
+            return false;
+    }
+    if (pJson.isMember("host_id")) {
+        if (!validJsonOfField(3, "host_id", pJson["host_id"], err, false))
+            return false;
+    }
+    if (pJson.isMember("session_id")) {
+        if (!validJsonOfField(4, "session_id", pJson["session_id"], err, false))
+            return false;
+    }
+    return true;
+}
+bool Rooms::validateMasqueradedJsonForUpdate(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 5) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty() &&
+            pJson.isMember(pMasqueradingVector[0])) {
+            if (!validJsonOfField(0, pMasqueradingVector[0],
+                                  pJson[pMasqueradingVector[0]], err, false))
+                return false;
+        } else {
+            err =
+                "The value of primary key must be set in the json object for "
+                "update";
+            return false;
+        }
+        if (!pMasqueradingVector[1].empty() &&
+            pJson.isMember(pMasqueradingVector[1])) {
+            if (!validJsonOfField(1, pMasqueradingVector[1],
+                                  pJson[pMasqueradingVector[1]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[2].empty() &&
+            pJson.isMember(pMasqueradingVector[2])) {
+            if (!validJsonOfField(2, pMasqueradingVector[2],
+                                  pJson[pMasqueradingVector[2]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[3].empty() &&
+            pJson.isMember(pMasqueradingVector[3])) {
+            if (!validJsonOfField(3, pMasqueradingVector[3],
+                                  pJson[pMasqueradingVector[3]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[4].empty() &&
+            pJson.isMember(pMasqueradingVector[4])) {
+            if (!validJsonOfField(4, pMasqueradingVector[4],
+                                  pJson[pMasqueradingVector[4]], err, false))
+                return false;
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Rooms::validJsonOfField(size_t index,
+                             const std::string &fieldName,
+                             const Json::Value &pJson,
+                             std::string &err,
+                             bool isForCreation) {
+    switch (index) {
+        case 0:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 1:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 2:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 3:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 4:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        default:
+            err = "Internal error in the server";
+            return false;
+            break;
+    }
+    return true;
+}
+void Rooms::getRoomJoins(const DbClientPtr &clientPtr,
+                         const std::function<void(std::vector<RoomJoins>)> &rcb,
+                         const ExceptionCallback &ecb) const {
+    const static std::string sql =
+        "select * from room_joins where room_id = $1";
+    *clientPtr << sql << *id_ >> [rcb = std::move(rcb)](const Result &r) {
+        std::vector<RoomJoins> ret;
+        ret.reserve(r.size());
+        for (auto const &row : r) {
+            ret.emplace_back(RoomJoins(row));
+        }
+        rcb(ret);
+    } >> ecb;
+}
diff --git a/server/sql-models/Rooms.h b/server/sql-models/Rooms.h
new file mode 100644
index 00000000..ea9809a0
--- /dev/null
+++ b/server/sql-models/Rooms.h
@@ -0,0 +1,279 @@
+/**
+ *
+ *  Rooms.h
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#pragma once
+#include <drogon/orm/Field.h>
+#include <drogon/orm/Mapper.h>
+#include <drogon/orm/Result.h>
+#include <drogon/orm/Row.h>
+#include <drogon/orm/SqlBinder.h>
+#ifdef __cpp_impl_coroutine
+#include <drogon/orm/CoroMapper.h>
+#endif
+#include <json/json.h>
+#include <stdint.h>
+#include <trantor/utils/Date.h>
+#include <trantor/utils/Logger.h>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace drogon {
+namespace orm {
+class DbClient;
+using DbClientPtr = std::shared_ptr<DbClient>;
+}  // namespace orm
+}  // namespace drogon
+namespace drogon_model {
+namespace cavoke_orm {
+class RoomJoins;
+
+class Rooms {
+public:
+    struct Cols {
+        static const std::string _id;
+        static const std::string _display_name;
+        static const std::string _invite_code;
+        static const std::string _host_id;
+        static const std::string _session_id;
+    };
+
+    const static int primaryKeyNumber;
+    const static std::string tableName;
+    const static bool hasPrimaryKey;
+    const static std::string primaryKeyName;
+    using PrimaryKeyType = std::string;
+    const PrimaryKeyType &getPrimaryKey() const;
+
+    /**
+     * @brief constructor
+     * @param r One row of records in the SQL query result.
+     * @param indexOffset Set the offset to -1 to access all columns by column
+     * names, otherwise access all columns by offsets.
+     * @note If the SQL is not a style of 'select * from table_name ...' (select
+     * all columns by an asterisk), please set the offset to -1.
+     */
+    explicit Rooms(const drogon::orm::Row &r,
+                   const ssize_t indexOffset = 0) noexcept;
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     */
+    explicit Rooms(const Json::Value &pJson) noexcept(false);
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     * @param pMasqueradingVector The aliases of table columns.
+     */
+    Rooms(const Json::Value &pJson,
+          const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+
+    Rooms() = default;
+
+    void updateByJson(const Json::Value &pJson) noexcept(false);
+    void updateByMasqueradedJson(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+    static bool validateJsonForCreation(const Json::Value &pJson,
+                                        std::string &err);
+    static bool validateMasqueradedJsonForCreation(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validateJsonForUpdate(const Json::Value &pJson,
+                                      std::string &err);
+    static bool validateMasqueradedJsonForUpdate(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validJsonOfField(size_t index,
+                                 const std::string &fieldName,
+                                 const Json::Value &pJson,
+                                 std::string &err,
+                                 bool isForCreation);
+
+    /**  For column id  */
+    /// Get the value of the column id, returns the default value if the column
+    /// is null
+    const std::string &getValueOfId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getId() const noexcept;
+    /// Set the value of the column id
+    void setId(const std::string &pId) noexcept;
+    void setId(std::string &&pId) noexcept;
+
+    /**  For column display_name  */
+    /// Get the value of the column display_name, returns the default value if
+    /// the column is null
+    const std::string &getValueOfDisplayName() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getDisplayName() const noexcept;
+    /// Set the value of the column display_name
+    void setDisplayName(const std::string &pDisplayName) noexcept;
+    void setDisplayName(std::string &&pDisplayName) noexcept;
+
+    /**  For column invite_code  */
+    /// Get the value of the column invite_code, returns the default value if
+    /// the column is null
+    const std::string &getValueOfInviteCode() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getInviteCode() const noexcept;
+    /// Set the value of the column invite_code
+    void setInviteCode(const std::string &pInviteCode) noexcept;
+    void setInviteCode(std::string &&pInviteCode) noexcept;
+
+    /**  For column host_id  */
+    /// Get the value of the column host_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfHostId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getHostId() const noexcept;
+    /// Set the value of the column host_id
+    void setHostId(const std::string &pHostId) noexcept;
+    void setHostId(std::string &&pHostId) noexcept;
+    void setHostIdToNull() noexcept;
+
+    /**  For column session_id  */
+    /// Get the value of the column session_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfSessionId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getSessionId() const noexcept;
+    /// Set the value of the column session_id
+    void setSessionId(const std::string &pSessionId) noexcept;
+    void setSessionId(std::string &&pSessionId) noexcept;
+    void setSessionIdToNull() noexcept;
+
+    static size_t getColumnNumber() noexcept {
+        return 5;
+    }
+    static const std::string &getColumnName(size_t index) noexcept(false);
+
+    Json::Value toJson() const;
+    Json::Value toMasqueradedJson(
+        const std::vector<std::string> &pMasqueradingVector) const;
+    /// Relationship interfaces
+    void getRoomJoins(const drogon::orm::DbClientPtr &clientPtr,
+                      const std::function<void(std::vector<RoomJoins>)> &rcb,
+                      const drogon::orm::ExceptionCallback &ecb) const;
+
+private:
+    friend drogon::orm::Mapper<Rooms>;
+#ifdef __cpp_impl_coroutine
+    friend drogon::orm::CoroMapper<Rooms>;
+#endif
+    static const std::vector<std::string> &insertColumns() noexcept;
+    void outputArgs(drogon::orm::internal::SqlBinder &binder) const;
+    const std::vector<std::string> updateColumns() const;
+    void updateArgs(drogon::orm::internal::SqlBinder &binder) const;
+    /// For mysql or sqlite3
+    void updateId(const uint64_t id);
+    std::shared_ptr<std::string> id_;
+    std::shared_ptr<std::string> displayName_;
+    std::shared_ptr<std::string> inviteCode_;
+    std::shared_ptr<std::string> hostId_;
+    std::shared_ptr<std::string> sessionId_;
+    struct MetaData {
+        const std::string colName_;
+        const std::string colType_;
+        const std::string colDatabaseType_;
+        const ssize_t colLength_;
+        const bool isAutoVal_;
+        const bool isPrimaryKey_;
+        const bool notNull_;
+    };
+    static const std::vector<MetaData> metaData_;
+    bool dirtyFlag_[5] = {false};
+
+public:
+    static const std::string &sqlForFindingByPrimaryKey() {
+        static const std::string sql =
+            "select * from " + tableName + " where id = $1";
+        return sql;
+    }
+
+    static const std::string &sqlForDeletingByPrimaryKey() {
+        static const std::string sql =
+            "delete from " + tableName + " where id = $1";
+        return sql;
+    }
+    std::string sqlForInserting(bool &needSelection) const {
+        std::string sql = "insert into " + tableName + " (";
+        size_t parametersCount = 0;
+        needSelection = false;
+        if (dirtyFlag_[0]) {
+            sql += "id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[1]) {
+            sql += "display_name,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[2]) {
+            sql += "invite_code,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[3]) {
+            sql += "host_id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[4]) {
+            sql += "session_id,";
+            ++parametersCount;
+        }
+        if (parametersCount > 0) {
+            sql[sql.length() - 1] = ')';
+            sql += " values (";
+        } else
+            sql += ") values (";
+
+        int placeholder = 1;
+        char placeholderStr[64];
+        size_t n = 0;
+        if (dirtyFlag_[0]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[1]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[2]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[3]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[4]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (parametersCount > 0) {
+            sql.resize(sql.length() - 1);
+        }
+        if (needSelection) {
+            sql.append(") returning *");
+        } else {
+            sql.append(1, ')');
+        }
+        LOG_TRACE << sql;
+        return sql;
+    }
+};
+}  // namespace cavoke_orm
+}  // namespace drogon_model
diff --git a/server/sql-models/Sessions.cc b/server/sql-models/Sessions.cc
new file mode 100644
index 00000000..fccde06f
--- /dev/null
+++ b/server/sql-models/Sessions.cc
@@ -0,0 +1,688 @@
+/**
+ *
+ *  Sessions.cc
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#include "Sessions.h"
+#include <drogon/utils/Utilities.h>
+#include <string>
+#include "Players.h"
+
+using namespace drogon;
+using namespace drogon::orm;
+using namespace drogon_model::cavoke_orm;
+
+const std::string Sessions::Cols::_id = "id";
+const std::string Sessions::Cols::_game_id = "game_id";
+const std::string Sessions::Cols::_host_id = "host_id";
+const std::string Sessions::Cols::_game_settings = "game_settings";
+const std::string Sessions::primaryKeyName = "id";
+const bool Sessions::hasPrimaryKey = true;
+const std::string Sessions::tableName = "sessions";
+
+const std::vector<typename Sessions::MetaData> Sessions::metaData_ = {
+    {"id", "std::string", "uuid", 0, 0, 1, 1},
+    {"game_id", "std::string", "character varying", 0, 0, 0, 1},
+    {"host_id", "std::string", "character varying", 0, 0, 0, 1},
+    {"game_settings", "std::string", "json", 0, 0, 0, 0}};
+const std::string &Sessions::getColumnName(size_t index) noexcept(false) {
+    assert(index < metaData_.size());
+    return metaData_[index].colName_;
+}
+Sessions::Sessions(const Row &r, const ssize_t indexOffset) noexcept {
+    if (indexOffset < 0) {
+        if (!r["id"].isNull()) {
+            id_ = std::make_shared<std::string>(r["id"].as<std::string>());
+        }
+        if (!r["game_id"].isNull()) {
+            gameId_ =
+                std::make_shared<std::string>(r["game_id"].as<std::string>());
+        }
+        if (!r["host_id"].isNull()) {
+            hostId_ =
+                std::make_shared<std::string>(r["host_id"].as<std::string>());
+        }
+        if (!r["game_settings"].isNull()) {
+            gameSettings_ = std::make_shared<std::string>(
+                r["game_settings"].as<std::string>());
+        }
+    } else {
+        size_t offset = (size_t)indexOffset;
+        if (offset + 4 > r.size()) {
+            LOG_FATAL << "Invalid SQL result for this model";
+            return;
+        }
+        size_t index;
+        index = offset + 0;
+        if (!r[index].isNull()) {
+            id_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 1;
+        if (!r[index].isNull()) {
+            gameId_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 2;
+        if (!r[index].isNull()) {
+            hostId_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 3;
+        if (!r[index].isNull()) {
+            gameSettings_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+    }
+}
+
+Sessions::Sessions(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 4) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        dirtyFlag_[0] = true;
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            id_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            gameId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            hostId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[2]].asString());
+        }
+    }
+    if (!pMasqueradingVector[3].empty() &&
+        pJson.isMember(pMasqueradingVector[3])) {
+        dirtyFlag_[3] = true;
+        if (!pJson[pMasqueradingVector[3]].isNull()) {
+            gameSettings_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[3]].asString());
+        }
+    }
+}
+
+Sessions::Sessions(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("id")) {
+        dirtyFlag_[0] = true;
+        if (!pJson["id"].isNull()) {
+            id_ = std::make_shared<std::string>(pJson["id"].asString());
+        }
+    }
+    if (pJson.isMember("game_id")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["game_id"].isNull()) {
+            gameId_ =
+                std::make_shared<std::string>(pJson["game_id"].asString());
+        }
+    }
+    if (pJson.isMember("host_id")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["host_id"].isNull()) {
+            hostId_ =
+                std::make_shared<std::string>(pJson["host_id"].asString());
+        }
+    }
+    if (pJson.isMember("game_settings")) {
+        dirtyFlag_[3] = true;
+        if (!pJson["game_settings"].isNull()) {
+            gameSettings_ = std::make_shared<std::string>(
+                pJson["game_settings"].asString());
+        }
+    }
+}
+
+void Sessions::updateByMasqueradedJson(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 4) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            id_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            gameId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            hostId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[2]].asString());
+        }
+    }
+    if (!pMasqueradingVector[3].empty() &&
+        pJson.isMember(pMasqueradingVector[3])) {
+        dirtyFlag_[3] = true;
+        if (!pJson[pMasqueradingVector[3]].isNull()) {
+            gameSettings_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[3]].asString());
+        }
+    }
+}
+
+void Sessions::updateByJson(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("id")) {
+        if (!pJson["id"].isNull()) {
+            id_ = std::make_shared<std::string>(pJson["id"].asString());
+        }
+    }
+    if (pJson.isMember("game_id")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["game_id"].isNull()) {
+            gameId_ =
+                std::make_shared<std::string>(pJson["game_id"].asString());
+        }
+    }
+    if (pJson.isMember("host_id")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["host_id"].isNull()) {
+            hostId_ =
+                std::make_shared<std::string>(pJson["host_id"].asString());
+        }
+    }
+    if (pJson.isMember("game_settings")) {
+        dirtyFlag_[3] = true;
+        if (!pJson["game_settings"].isNull()) {
+            gameSettings_ = std::make_shared<std::string>(
+                pJson["game_settings"].asString());
+        }
+    }
+}
+
+const std::string &Sessions::getValueOfId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (id_)
+        return *id_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Sessions::getId() const noexcept {
+    return id_;
+}
+void Sessions::setId(const std::string &pId) noexcept {
+    id_ = std::make_shared<std::string>(pId);
+    dirtyFlag_[0] = true;
+}
+void Sessions::setId(std::string &&pId) noexcept {
+    id_ = std::make_shared<std::string>(std::move(pId));
+    dirtyFlag_[0] = true;
+}
+const typename Sessions::PrimaryKeyType &Sessions::getPrimaryKey() const {
+    assert(id_);
+    return *id_;
+}
+
+const std::string &Sessions::getValueOfGameId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (gameId_)
+        return *gameId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Sessions::getGameId() const noexcept {
+    return gameId_;
+}
+void Sessions::setGameId(const std::string &pGameId) noexcept {
+    gameId_ = std::make_shared<std::string>(pGameId);
+    dirtyFlag_[1] = true;
+}
+void Sessions::setGameId(std::string &&pGameId) noexcept {
+    gameId_ = std::make_shared<std::string>(std::move(pGameId));
+    dirtyFlag_[1] = true;
+}
+
+const std::string &Sessions::getValueOfHostId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (hostId_)
+        return *hostId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Sessions::getHostId() const noexcept {
+    return hostId_;
+}
+void Sessions::setHostId(const std::string &pHostId) noexcept {
+    hostId_ = std::make_shared<std::string>(pHostId);
+    dirtyFlag_[2] = true;
+}
+void Sessions::setHostId(std::string &&pHostId) noexcept {
+    hostId_ = std::make_shared<std::string>(std::move(pHostId));
+    dirtyFlag_[2] = true;
+}
+
+const std::string &Sessions::getValueOfGameSettings() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (gameSettings_)
+        return *gameSettings_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Sessions::getGameSettings() const noexcept {
+    return gameSettings_;
+}
+void Sessions::setGameSettings(const std::string &pGameSettings) noexcept {
+    gameSettings_ = std::make_shared<std::string>(pGameSettings);
+    dirtyFlag_[3] = true;
+}
+void Sessions::setGameSettings(std::string &&pGameSettings) noexcept {
+    gameSettings_ = std::make_shared<std::string>(std::move(pGameSettings));
+    dirtyFlag_[3] = true;
+}
+void Sessions::setGameSettingsToNull() noexcept {
+    gameSettings_.reset();
+    dirtyFlag_[3] = true;
+}
+
+void Sessions::updateId(const uint64_t id) {
+}
+
+const std::vector<std::string> &Sessions::insertColumns() noexcept {
+    static const std::vector<std::string> inCols = {"id", "game_id", "host_id",
+                                                    "game_settings"};
+    return inCols;
+}
+
+void Sessions::outputArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getId()) {
+            binder << getValueOfId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getGameId()) {
+            binder << getValueOfGameId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getHostId()) {
+            binder << getValueOfHostId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[3]) {
+        if (getGameSettings()) {
+            binder << getValueOfGameSettings();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+
+const std::vector<std::string> Sessions::updateColumns() const {
+    std::vector<std::string> ret;
+    if (dirtyFlag_[0]) {
+        ret.push_back(getColumnName(0));
+    }
+    if (dirtyFlag_[1]) {
+        ret.push_back(getColumnName(1));
+    }
+    if (dirtyFlag_[2]) {
+        ret.push_back(getColumnName(2));
+    }
+    if (dirtyFlag_[3]) {
+        ret.push_back(getColumnName(3));
+    }
+    return ret;
+}
+
+void Sessions::updateArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getId()) {
+            binder << getValueOfId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getGameId()) {
+            binder << getValueOfGameId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getHostId()) {
+            binder << getValueOfHostId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[3]) {
+        if (getGameSettings()) {
+            binder << getValueOfGameSettings();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+Json::Value Sessions::toJson() const {
+    Json::Value ret;
+    if (getId()) {
+        ret["id"] = getValueOfId();
+    } else {
+        ret["id"] = Json::Value();
+    }
+    if (getGameId()) {
+        ret["game_id"] = getValueOfGameId();
+    } else {
+        ret["game_id"] = Json::Value();
+    }
+    if (getHostId()) {
+        ret["host_id"] = getValueOfHostId();
+    } else {
+        ret["host_id"] = Json::Value();
+    }
+    if (getGameSettings()) {
+        ret["game_settings"] = getValueOfGameSettings();
+    } else {
+        ret["game_settings"] = Json::Value();
+    }
+    return ret;
+}
+
+Json::Value Sessions::toMasqueradedJson(
+    const std::vector<std::string> &pMasqueradingVector) const {
+    Json::Value ret;
+    if (pMasqueradingVector.size() == 4) {
+        if (!pMasqueradingVector[0].empty()) {
+            if (getId()) {
+                ret[pMasqueradingVector[0]] = getValueOfId();
+            } else {
+                ret[pMasqueradingVector[0]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (getGameId()) {
+                ret[pMasqueradingVector[1]] = getValueOfGameId();
+            } else {
+                ret[pMasqueradingVector[1]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (getHostId()) {
+                ret[pMasqueradingVector[2]] = getValueOfHostId();
+            } else {
+                ret[pMasqueradingVector[2]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[3].empty()) {
+            if (getGameSettings()) {
+                ret[pMasqueradingVector[3]] = getValueOfGameSettings();
+            } else {
+                ret[pMasqueradingVector[3]] = Json::Value();
+            }
+        }
+        return ret;
+    }
+    LOG_ERROR << "Masquerade failed";
+    if (getId()) {
+        ret["id"] = getValueOfId();
+    } else {
+        ret["id"] = Json::Value();
+    }
+    if (getGameId()) {
+        ret["game_id"] = getValueOfGameId();
+    } else {
+        ret["game_id"] = Json::Value();
+    }
+    if (getHostId()) {
+        ret["host_id"] = getValueOfHostId();
+    } else {
+        ret["host_id"] = Json::Value();
+    }
+    if (getGameSettings()) {
+        ret["game_settings"] = getValueOfGameSettings();
+    } else {
+        ret["game_settings"] = Json::Value();
+    }
+    return ret;
+}
+
+bool Sessions::validateJsonForCreation(const Json::Value &pJson,
+                                       std::string &err) {
+    if (pJson.isMember("id")) {
+        if (!validJsonOfField(0, "id", pJson["id"], err, true))
+            return false;
+    } else {
+        err = "The id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("game_id")) {
+        if (!validJsonOfField(1, "game_id", pJson["game_id"], err, true))
+            return false;
+    } else {
+        err = "The game_id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("host_id")) {
+        if (!validJsonOfField(2, "host_id", pJson["host_id"], err, true))
+            return false;
+    } else {
+        err = "The host_id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("game_settings")) {
+        if (!validJsonOfField(3, "game_settings", pJson["game_settings"], err,
+                              true))
+            return false;
+    }
+    return true;
+}
+bool Sessions::validateMasqueradedJsonForCreation(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 4) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty()) {
+            if (pJson.isMember(pMasqueradingVector[0])) {
+                if (!validJsonOfField(0, pMasqueradingVector[0],
+                                      pJson[pMasqueradingVector[0]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[0] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (pJson.isMember(pMasqueradingVector[1])) {
+                if (!validJsonOfField(1, pMasqueradingVector[1],
+                                      pJson[pMasqueradingVector[1]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[1] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (pJson.isMember(pMasqueradingVector[2])) {
+                if (!validJsonOfField(2, pMasqueradingVector[2],
+                                      pJson[pMasqueradingVector[2]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[2] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[3].empty()) {
+            if (pJson.isMember(pMasqueradingVector[3])) {
+                if (!validJsonOfField(3, pMasqueradingVector[3],
+                                      pJson[pMasqueradingVector[3]], err, true))
+                    return false;
+            }
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Sessions::validateJsonForUpdate(const Json::Value &pJson,
+                                     std::string &err) {
+    if (pJson.isMember("id")) {
+        if (!validJsonOfField(0, "id", pJson["id"], err, false))
+            return false;
+    } else {
+        err =
+            "The value of primary key must be set in the json object for "
+            "update";
+        return false;
+    }
+    if (pJson.isMember("game_id")) {
+        if (!validJsonOfField(1, "game_id", pJson["game_id"], err, false))
+            return false;
+    }
+    if (pJson.isMember("host_id")) {
+        if (!validJsonOfField(2, "host_id", pJson["host_id"], err, false))
+            return false;
+    }
+    if (pJson.isMember("game_settings")) {
+        if (!validJsonOfField(3, "game_settings", pJson["game_settings"], err,
+                              false))
+            return false;
+    }
+    return true;
+}
+bool Sessions::validateMasqueradedJsonForUpdate(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 4) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty() &&
+            pJson.isMember(pMasqueradingVector[0])) {
+            if (!validJsonOfField(0, pMasqueradingVector[0],
+                                  pJson[pMasqueradingVector[0]], err, false))
+                return false;
+        } else {
+            err =
+                "The value of primary key must be set in the json object for "
+                "update";
+            return false;
+        }
+        if (!pMasqueradingVector[1].empty() &&
+            pJson.isMember(pMasqueradingVector[1])) {
+            if (!validJsonOfField(1, pMasqueradingVector[1],
+                                  pJson[pMasqueradingVector[1]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[2].empty() &&
+            pJson.isMember(pMasqueradingVector[2])) {
+            if (!validJsonOfField(2, pMasqueradingVector[2],
+                                  pJson[pMasqueradingVector[2]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[3].empty() &&
+            pJson.isMember(pMasqueradingVector[3])) {
+            if (!validJsonOfField(3, pMasqueradingVector[3],
+                                  pJson[pMasqueradingVector[3]], err, false))
+                return false;
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Sessions::validJsonOfField(size_t index,
+                                const std::string &fieldName,
+                                const Json::Value &pJson,
+                                std::string &err,
+                                bool isForCreation) {
+    switch (index) {
+        case 0:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 1:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 2:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 3:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        default:
+            err = "Internal error in the server";
+            return false;
+            break;
+    }
+    return true;
+}
+void Sessions::getPlayers(const DbClientPtr &clientPtr,
+                          const std::function<void(std::vector<Players>)> &rcb,
+                          const ExceptionCallback &ecb) const {
+    const static std::string sql =
+        "select * from players where session_id = $1";
+    *clientPtr << sql << *id_ >> [rcb = std::move(rcb)](const Result &r) {
+        std::vector<Players> ret;
+        ret.reserve(r.size());
+        for (auto const &row : r) {
+            ret.emplace_back(Players(row));
+        }
+        rcb(ret);
+    } >> ecb;
+}
diff --git a/server/sql-models/Sessions.h b/server/sql-models/Sessions.h
new file mode 100644
index 00000000..a219da01
--- /dev/null
+++ b/server/sql-models/Sessions.h
@@ -0,0 +1,258 @@
+/**
+ *
+ *  Sessions.h
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#pragma once
+#include <drogon/orm/Field.h>
+#include <drogon/orm/Mapper.h>
+#include <drogon/orm/Result.h>
+#include <drogon/orm/Row.h>
+#include <drogon/orm/SqlBinder.h>
+#ifdef __cpp_impl_coroutine
+#include <drogon/orm/CoroMapper.h>
+#endif
+#include <json/json.h>
+#include <stdint.h>
+#include <trantor/utils/Date.h>
+#include <trantor/utils/Logger.h>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace drogon {
+namespace orm {
+class DbClient;
+using DbClientPtr = std::shared_ptr<DbClient>;
+}  // namespace orm
+}  // namespace drogon
+namespace drogon_model {
+namespace cavoke_orm {
+class Players;
+
+class Sessions {
+public:
+    struct Cols {
+        static const std::string _id;
+        static const std::string _game_id;
+        static const std::string _host_id;
+        static const std::string _game_settings;
+    };
+
+    const static int primaryKeyNumber;
+    const static std::string tableName;
+    const static bool hasPrimaryKey;
+    const static std::string primaryKeyName;
+    using PrimaryKeyType = std::string;
+    const PrimaryKeyType &getPrimaryKey() const;
+
+    /**
+     * @brief constructor
+     * @param r One row of records in the SQL query result.
+     * @param indexOffset Set the offset to -1 to access all columns by column
+     * names, otherwise access all columns by offsets.
+     * @note If the SQL is not a style of 'select * from table_name ...' (select
+     * all columns by an asterisk), please set the offset to -1.
+     */
+    explicit Sessions(const drogon::orm::Row &r,
+                      const ssize_t indexOffset = 0) noexcept;
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     */
+    explicit Sessions(const Json::Value &pJson) noexcept(false);
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     * @param pMasqueradingVector The aliases of table columns.
+     */
+    Sessions(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+
+    Sessions() = default;
+
+    void updateByJson(const Json::Value &pJson) noexcept(false);
+    void updateByMasqueradedJson(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+    static bool validateJsonForCreation(const Json::Value &pJson,
+                                        std::string &err);
+    static bool validateMasqueradedJsonForCreation(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validateJsonForUpdate(const Json::Value &pJson,
+                                      std::string &err);
+    static bool validateMasqueradedJsonForUpdate(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validJsonOfField(size_t index,
+                                 const std::string &fieldName,
+                                 const Json::Value &pJson,
+                                 std::string &err,
+                                 bool isForCreation);
+
+    /**  For column id  */
+    /// Get the value of the column id, returns the default value if the column
+    /// is null
+    const std::string &getValueOfId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getId() const noexcept;
+    /// Set the value of the column id
+    void setId(const std::string &pId) noexcept;
+    void setId(std::string &&pId) noexcept;
+
+    /**  For column game_id  */
+    /// Get the value of the column game_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfGameId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getGameId() const noexcept;
+    /// Set the value of the column game_id
+    void setGameId(const std::string &pGameId) noexcept;
+    void setGameId(std::string &&pGameId) noexcept;
+
+    /**  For column host_id  */
+    /// Get the value of the column host_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfHostId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getHostId() const noexcept;
+    /// Set the value of the column host_id
+    void setHostId(const std::string &pHostId) noexcept;
+    void setHostId(std::string &&pHostId) noexcept;
+
+    /**  For column game_settings  */
+    /// Get the value of the column game_settings, returns the default value if
+    /// the column is null
+    const std::string &getValueOfGameSettings() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getGameSettings() const noexcept;
+    /// Set the value of the column game_settings
+    void setGameSettings(const std::string &pGameSettings) noexcept;
+    void setGameSettings(std::string &&pGameSettings) noexcept;
+    void setGameSettingsToNull() noexcept;
+
+    static size_t getColumnNumber() noexcept {
+        return 4;
+    }
+    static const std::string &getColumnName(size_t index) noexcept(false);
+
+    Json::Value toJson() const;
+    Json::Value toMasqueradedJson(
+        const std::vector<std::string> &pMasqueradingVector) const;
+    /// Relationship interfaces
+    void getPlayers(const drogon::orm::DbClientPtr &clientPtr,
+                    const std::function<void(std::vector<Players>)> &rcb,
+                    const drogon::orm::ExceptionCallback &ecb) const;
+
+private:
+    friend drogon::orm::Mapper<Sessions>;
+#ifdef __cpp_impl_coroutine
+    friend drogon::orm::CoroMapper<Sessions>;
+#endif
+    static const std::vector<std::string> &insertColumns() noexcept;
+    void outputArgs(drogon::orm::internal::SqlBinder &binder) const;
+    const std::vector<std::string> updateColumns() const;
+    void updateArgs(drogon::orm::internal::SqlBinder &binder) const;
+    /// For mysql or sqlite3
+    void updateId(const uint64_t id);
+    std::shared_ptr<std::string> id_;
+    std::shared_ptr<std::string> gameId_;
+    std::shared_ptr<std::string> hostId_;
+    std::shared_ptr<std::string> gameSettings_;
+    struct MetaData {
+        const std::string colName_;
+        const std::string colType_;
+        const std::string colDatabaseType_;
+        const ssize_t colLength_;
+        const bool isAutoVal_;
+        const bool isPrimaryKey_;
+        const bool notNull_;
+    };
+    static const std::vector<MetaData> metaData_;
+    bool dirtyFlag_[4] = {false};
+
+public:
+    static const std::string &sqlForFindingByPrimaryKey() {
+        static const std::string sql =
+            "select * from " + tableName + " where id = $1";
+        return sql;
+    }
+
+    static const std::string &sqlForDeletingByPrimaryKey() {
+        static const std::string sql =
+            "delete from " + tableName + " where id = $1";
+        return sql;
+    }
+    std::string sqlForInserting(bool &needSelection) const {
+        std::string sql = "insert into " + tableName + " (";
+        size_t parametersCount = 0;
+        needSelection = false;
+        if (dirtyFlag_[0]) {
+            sql += "id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[1]) {
+            sql += "game_id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[2]) {
+            sql += "host_id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[3]) {
+            sql += "game_settings,";
+            ++parametersCount;
+        }
+        if (parametersCount > 0) {
+            sql[sql.length() - 1] = ')';
+            sql += " values (";
+        } else
+            sql += ") values (";
+
+        int placeholder = 1;
+        char placeholderStr[64];
+        size_t n = 0;
+        if (dirtyFlag_[0]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[1]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[2]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[3]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (parametersCount > 0) {
+            sql.resize(sql.length() - 1);
+        }
+        if (needSelection) {
+            sql.append(") returning *");
+        } else {
+            sql.append(1, ')');
+        }
+        LOG_TRACE << sql;
+        return sql;
+    }
+};
+}  // namespace cavoke_orm
+}  // namespace drogon_model
diff --git a/server/sql-models/Statuses.cc b/server/sql-models/Statuses.cc
new file mode 100644
index 00000000..db2e04b7
--- /dev/null
+++ b/server/sql-models/Statuses.cc
@@ -0,0 +1,610 @@
+/**
+ *
+ *  Statuses.cc
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#include "Statuses.h"
+#include <drogon/utils/Utilities.h>
+#include <string>
+
+using namespace drogon;
+using namespace drogon::orm;
+using namespace drogon_model::cavoke_orm;
+
+const std::string Statuses::Cols::_session_id = "session_id";
+const std::string Statuses::Cols::_status = "status";
+const std::string Statuses::Cols::_saved_on = "saved_on";
+const std::string Statuses::primaryKeyName = "";
+const bool Statuses::hasPrimaryKey = false;
+const std::string Statuses::tableName = "statuses";
+
+const std::vector<typename Statuses::MetaData> Statuses::metaData_ = {
+    {"session_id", "std::string", "uuid", 0, 0, 0, 1},
+    {"status", "int32_t", "integer", 4, 0, 0, 0},
+    {"saved_on", "::trantor::Date", "timestamp without time zone", 0, 0, 0, 0}};
+const std::string &Statuses::getColumnName(size_t index) noexcept(false) {
+    assert(index < metaData_.size());
+    return metaData_[index].colName_;
+}
+Statuses::Statuses(const Row &r, const ssize_t indexOffset) noexcept {
+    if (indexOffset < 0) {
+        if (!r["session_id"].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                r["session_id"].as<std::string>());
+        }
+        if (!r["status"].isNull()) {
+            status_ = std::make_shared<int32_t>(r["status"].as<int32_t>());
+        }
+        if (!r["saved_on"].isNull()) {
+            auto timeStr = r["saved_on"].as<std::string>();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    } else {
+        size_t offset = (size_t)indexOffset;
+        if (offset + 3 > r.size()) {
+            LOG_FATAL << "Invalid SQL result for this model";
+            return;
+        }
+        size_t index;
+        index = offset + 0;
+        if (!r[index].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 1;
+        if (!r[index].isNull()) {
+            status_ = std::make_shared<int32_t>(r[index].as<int32_t>());
+        }
+        index = offset + 2;
+        if (!r[index].isNull()) {
+            auto timeStr = r[index].as<std::string>();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+}
+
+Statuses::Statuses(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 3) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        dirtyFlag_[0] = true;
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            status_ = std::make_shared<int32_t>(
+                (int32_t)pJson[pMasqueradingVector[1]].asInt64());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            auto timeStr = pJson[pMasqueradingVector[2]].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+}
+
+Statuses::Statuses(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("session_id")) {
+        dirtyFlag_[0] = true;
+        if (!pJson["session_id"].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(pJson["session_id"].asString());
+        }
+    }
+    if (pJson.isMember("status")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["status"].isNull()) {
+            status_ =
+                std::make_shared<int32_t>((int32_t)pJson["status"].asInt64());
+        }
+    }
+    if (pJson.isMember("saved_on")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["saved_on"].isNull()) {
+            auto timeStr = pJson["saved_on"].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+}
+
+void Statuses::updateByMasqueradedJson(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 3) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        dirtyFlag_[0] = true;
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            sessionId_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            status_ = std::make_shared<int32_t>(
+                (int32_t)pJson[pMasqueradingVector[1]].asInt64());
+        }
+    }
+    if (!pMasqueradingVector[2].empty() &&
+        pJson.isMember(pMasqueradingVector[2])) {
+        dirtyFlag_[2] = true;
+        if (!pJson[pMasqueradingVector[2]].isNull()) {
+            auto timeStr = pJson[pMasqueradingVector[2]].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+}
+
+void Statuses::updateByJson(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("session_id")) {
+        dirtyFlag_[0] = true;
+        if (!pJson["session_id"].isNull()) {
+            sessionId_ =
+                std::make_shared<std::string>(pJson["session_id"].asString());
+        }
+    }
+    if (pJson.isMember("status")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["status"].isNull()) {
+            status_ =
+                std::make_shared<int32_t>((int32_t)pJson["status"].asInt64());
+        }
+    }
+    if (pJson.isMember("saved_on")) {
+        dirtyFlag_[2] = true;
+        if (!pJson["saved_on"].isNull()) {
+            auto timeStr = pJson["saved_on"].asString();
+            struct tm stm;
+            memset(&stm, 0, sizeof(stm));
+            auto p = strptime(timeStr.c_str(), "%Y-%m-%d %H:%M:%S", &stm);
+            time_t t = mktime(&stm);
+            size_t decimalNum = 0;
+            if (p) {
+                if (*p == '.') {
+                    std::string decimals(p + 1, &timeStr[timeStr.length()]);
+                    while (decimals.length() < 6) {
+                        decimals += "0";
+                    }
+                    decimalNum = (size_t)atol(decimals.c_str());
+                }
+                savedOn_ =
+                    std::make_shared<::trantor::Date>(t * 1000000 + decimalNum);
+            }
+        }
+    }
+}
+
+const std::string &Statuses::getValueOfSessionId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (sessionId_)
+        return *sessionId_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Statuses::getSessionId() const noexcept {
+    return sessionId_;
+}
+void Statuses::setSessionId(const std::string &pSessionId) noexcept {
+    sessionId_ = std::make_shared<std::string>(pSessionId);
+    dirtyFlag_[0] = true;
+}
+void Statuses::setSessionId(std::string &&pSessionId) noexcept {
+    sessionId_ = std::make_shared<std::string>(std::move(pSessionId));
+    dirtyFlag_[0] = true;
+}
+
+const int32_t &Statuses::getValueOfStatus() const noexcept {
+    const static int32_t defaultValue = int32_t();
+    if (status_)
+        return *status_;
+    return defaultValue;
+}
+const std::shared_ptr<int32_t> &Statuses::getStatus() const noexcept {
+    return status_;
+}
+void Statuses::setStatus(const int32_t &pStatus) noexcept {
+    status_ = std::make_shared<int32_t>(pStatus);
+    dirtyFlag_[1] = true;
+}
+void Statuses::setStatusToNull() noexcept {
+    status_.reset();
+    dirtyFlag_[1] = true;
+}
+
+const ::trantor::Date &Statuses::getValueOfSavedOn() const noexcept {
+    const static ::trantor::Date defaultValue = ::trantor::Date();
+    if (savedOn_)
+        return *savedOn_;
+    return defaultValue;
+}
+const std::shared_ptr<::trantor::Date> &Statuses::getSavedOn() const noexcept {
+    return savedOn_;
+}
+void Statuses::setSavedOn(const ::trantor::Date &pSavedOn) noexcept {
+    savedOn_ = std::make_shared<::trantor::Date>(pSavedOn);
+    dirtyFlag_[2] = true;
+}
+void Statuses::setSavedOnToNull() noexcept {
+    savedOn_.reset();
+    dirtyFlag_[2] = true;
+}
+
+void Statuses::updateId(const uint64_t id) {
+}
+
+const std::vector<std::string> &Statuses::insertColumns() noexcept {
+    static const std::vector<std::string> inCols = {"session_id", "status",
+                                                    "saved_on"};
+    return inCols;
+}
+
+void Statuses::outputArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getSessionId()) {
+            binder << getValueOfSessionId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getStatus()) {
+            binder << getValueOfStatus();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getSavedOn()) {
+            binder << getValueOfSavedOn();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+
+const std::vector<std::string> Statuses::updateColumns() const {
+    std::vector<std::string> ret;
+    if (dirtyFlag_[0]) {
+        ret.push_back(getColumnName(0));
+    }
+    if (dirtyFlag_[1]) {
+        ret.push_back(getColumnName(1));
+    }
+    if (dirtyFlag_[2]) {
+        ret.push_back(getColumnName(2));
+    }
+    return ret;
+}
+
+void Statuses::updateArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getSessionId()) {
+            binder << getValueOfSessionId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getStatus()) {
+            binder << getValueOfStatus();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[2]) {
+        if (getSavedOn()) {
+            binder << getValueOfSavedOn();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+Json::Value Statuses::toJson() const {
+    Json::Value ret;
+    if (getSessionId()) {
+        ret["session_id"] = getValueOfSessionId();
+    } else {
+        ret["session_id"] = Json::Value();
+    }
+    if (getStatus()) {
+        ret["status"] = getValueOfStatus();
+    } else {
+        ret["status"] = Json::Value();
+    }
+    if (getSavedOn()) {
+        ret["saved_on"] = getSavedOn()->toDbStringLocal();
+    } else {
+        ret["saved_on"] = Json::Value();
+    }
+    return ret;
+}
+
+Json::Value Statuses::toMasqueradedJson(
+    const std::vector<std::string> &pMasqueradingVector) const {
+    Json::Value ret;
+    if (pMasqueradingVector.size() == 3) {
+        if (!pMasqueradingVector[0].empty()) {
+            if (getSessionId()) {
+                ret[pMasqueradingVector[0]] = getValueOfSessionId();
+            } else {
+                ret[pMasqueradingVector[0]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (getStatus()) {
+                ret[pMasqueradingVector[1]] = getValueOfStatus();
+            } else {
+                ret[pMasqueradingVector[1]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (getSavedOn()) {
+                ret[pMasqueradingVector[2]] = getSavedOn()->toDbStringLocal();
+            } else {
+                ret[pMasqueradingVector[2]] = Json::Value();
+            }
+        }
+        return ret;
+    }
+    LOG_ERROR << "Masquerade failed";
+    if (getSessionId()) {
+        ret["session_id"] = getValueOfSessionId();
+    } else {
+        ret["session_id"] = Json::Value();
+    }
+    if (getStatus()) {
+        ret["status"] = getValueOfStatus();
+    } else {
+        ret["status"] = Json::Value();
+    }
+    if (getSavedOn()) {
+        ret["saved_on"] = getSavedOn()->toDbStringLocal();
+    } else {
+        ret["saved_on"] = Json::Value();
+    }
+    return ret;
+}
+
+bool Statuses::validateJsonForCreation(const Json::Value &pJson,
+                                       std::string &err) {
+    if (pJson.isMember("session_id")) {
+        if (!validJsonOfField(0, "session_id", pJson["session_id"], err, true))
+            return false;
+    } else {
+        err = "The session_id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("status")) {
+        if (!validJsonOfField(1, "status", pJson["status"], err, true))
+            return false;
+    }
+    if (pJson.isMember("saved_on")) {
+        if (!validJsonOfField(2, "saved_on", pJson["saved_on"], err, true))
+            return false;
+    }
+    return true;
+}
+bool Statuses::validateMasqueradedJsonForCreation(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 3) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty()) {
+            if (pJson.isMember(pMasqueradingVector[0])) {
+                if (!validJsonOfField(0, pMasqueradingVector[0],
+                                      pJson[pMasqueradingVector[0]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[0] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (pJson.isMember(pMasqueradingVector[1])) {
+                if (!validJsonOfField(1, pMasqueradingVector[1],
+                                      pJson[pMasqueradingVector[1]], err, true))
+                    return false;
+            }
+        }
+        if (!pMasqueradingVector[2].empty()) {
+            if (pJson.isMember(pMasqueradingVector[2])) {
+                if (!validJsonOfField(2, pMasqueradingVector[2],
+                                      pJson[pMasqueradingVector[2]], err, true))
+                    return false;
+            }
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Statuses::validateJsonForUpdate(const Json::Value &pJson,
+                                     std::string &err) {
+    if (pJson.isMember("session_id")) {
+        if (!validJsonOfField(0, "session_id", pJson["session_id"], err, false))
+            return false;
+    }
+    if (pJson.isMember("status")) {
+        if (!validJsonOfField(1, "status", pJson["status"], err, false))
+            return false;
+    }
+    if (pJson.isMember("saved_on")) {
+        if (!validJsonOfField(2, "saved_on", pJson["saved_on"], err, false))
+            return false;
+    }
+    return true;
+}
+bool Statuses::validateMasqueradedJsonForUpdate(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 3) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty() &&
+            pJson.isMember(pMasqueradingVector[0])) {
+            if (!validJsonOfField(0, pMasqueradingVector[0],
+                                  pJson[pMasqueradingVector[0]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[1].empty() &&
+            pJson.isMember(pMasqueradingVector[1])) {
+            if (!validJsonOfField(1, pMasqueradingVector[1],
+                                  pJson[pMasqueradingVector[1]], err, false))
+                return false;
+        }
+        if (!pMasqueradingVector[2].empty() &&
+            pJson.isMember(pMasqueradingVector[2])) {
+            if (!validJsonOfField(2, pMasqueradingVector[2],
+                                  pJson[pMasqueradingVector[2]], err, false))
+                return false;
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Statuses::validJsonOfField(size_t index,
+                                const std::string &fieldName,
+                                const Json::Value &pJson,
+                                std::string &err,
+                                bool isForCreation) {
+    switch (index) {
+        case 0:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 1:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isInt()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 2:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        default:
+            err = "Internal error in the server";
+            return false;
+            break;
+    }
+    return true;
+}
diff --git a/server/sql-models/Statuses.h b/server/sql-models/Statuses.h
new file mode 100644
index 00000000..068be361
--- /dev/null
+++ b/server/sql-models/Statuses.h
@@ -0,0 +1,235 @@
+/**
+ *
+ *  Statuses.h
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#pragma once
+#include <drogon/orm/Field.h>
+#include <drogon/orm/Mapper.h>
+#include <drogon/orm/Result.h>
+#include <drogon/orm/Row.h>
+#include <drogon/orm/SqlBinder.h>
+#ifdef __cpp_impl_coroutine
+#include <drogon/orm/CoroMapper.h>
+#endif
+#include <json/json.h>
+#include <stdint.h>
+#include <trantor/utils/Date.h>
+#include <trantor/utils/Logger.h>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace drogon {
+namespace orm {
+class DbClient;
+using DbClientPtr = std::shared_ptr<DbClient>;
+}  // namespace orm
+}  // namespace drogon
+namespace drogon_model {
+namespace cavoke_orm {
+
+class Statuses {
+public:
+    struct Cols {
+        static const std::string _session_id;
+        static const std::string _status;
+        static const std::string _saved_on;
+    };
+
+    const static int primaryKeyNumber;
+    const static std::string tableName;
+    const static bool hasPrimaryKey;
+    const static std::string primaryKeyName;
+    using PrimaryKeyType = void;
+    int getPrimaryKey() const {
+        assert(false);
+        return 0;
+    }
+
+    /**
+     * @brief constructor
+     * @param r One row of records in the SQL query result.
+     * @param indexOffset Set the offset to -1 to access all columns by column
+     * names, otherwise access all columns by offsets.
+     * @note If the SQL is not a style of 'select * from table_name ...' (select
+     * all columns by an asterisk), please set the offset to -1.
+     */
+    explicit Statuses(const drogon::orm::Row &r,
+                      const ssize_t indexOffset = 0) noexcept;
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     */
+    explicit Statuses(const Json::Value &pJson) noexcept(false);
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     * @param pMasqueradingVector The aliases of table columns.
+     */
+    Statuses(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+
+    Statuses() = default;
+
+    void updateByJson(const Json::Value &pJson) noexcept(false);
+    void updateByMasqueradedJson(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+    static bool validateJsonForCreation(const Json::Value &pJson,
+                                        std::string &err);
+    static bool validateMasqueradedJsonForCreation(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validateJsonForUpdate(const Json::Value &pJson,
+                                      std::string &err);
+    static bool validateMasqueradedJsonForUpdate(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validJsonOfField(size_t index,
+                                 const std::string &fieldName,
+                                 const Json::Value &pJson,
+                                 std::string &err,
+                                 bool isForCreation);
+
+    /**  For column session_id  */
+    /// Get the value of the column session_id, returns the default value if the
+    /// column is null
+    const std::string &getValueOfSessionId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getSessionId() const noexcept;
+    /// Set the value of the column session_id
+    void setSessionId(const std::string &pSessionId) noexcept;
+    void setSessionId(std::string &&pSessionId) noexcept;
+
+    /**  For column status  */
+    /// Get the value of the column status, returns the default value if the
+    /// column is null
+    const int32_t &getValueOfStatus() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<int32_t> &getStatus() const noexcept;
+    /// Set the value of the column status
+    void setStatus(const int32_t &pStatus) noexcept;
+    void setStatusToNull() noexcept;
+
+    /**  For column saved_on  */
+    /// Get the value of the column saved_on, returns the default value if the
+    /// column is null
+    const ::trantor::Date &getValueOfSavedOn() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<::trantor::Date> &getSavedOn() const noexcept;
+    /// Set the value of the column saved_on
+    void setSavedOn(const ::trantor::Date &pSavedOn) noexcept;
+    void setSavedOnToNull() noexcept;
+
+    static size_t getColumnNumber() noexcept {
+        return 3;
+    }
+    static const std::string &getColumnName(size_t index) noexcept(false);
+
+    Json::Value toJson() const;
+    Json::Value toMasqueradedJson(
+        const std::vector<std::string> &pMasqueradingVector) const;
+    /// Relationship interfaces
+private:
+    friend drogon::orm::Mapper<Statuses>;
+#ifdef __cpp_impl_coroutine
+    friend drogon::orm::CoroMapper<Statuses>;
+#endif
+    static const std::vector<std::string> &insertColumns() noexcept;
+    void outputArgs(drogon::orm::internal::SqlBinder &binder) const;
+    const std::vector<std::string> updateColumns() const;
+    void updateArgs(drogon::orm::internal::SqlBinder &binder) const;
+    /// For mysql or sqlite3
+    void updateId(const uint64_t id);
+    std::shared_ptr<std::string> sessionId_;
+    std::shared_ptr<int32_t> status_;
+    std::shared_ptr<::trantor::Date> savedOn_;
+    struct MetaData {
+        const std::string colName_;
+        const std::string colType_;
+        const std::string colDatabaseType_;
+        const ssize_t colLength_;
+        const bool isAutoVal_;
+        const bool isPrimaryKey_;
+        const bool notNull_;
+    };
+    static const std::vector<MetaData> metaData_;
+    bool dirtyFlag_[3] = {false};
+
+public:
+    static const std::string &sqlForFindingByPrimaryKey() {
+        static const std::string sql = "";
+        return sql;
+    }
+
+    static const std::string &sqlForDeletingByPrimaryKey() {
+        static const std::string sql = "";
+        return sql;
+    }
+    std::string sqlForInserting(bool &needSelection) const {
+        std::string sql = "insert into " + tableName + " (";
+        size_t parametersCount = 0;
+        needSelection = false;
+        if (dirtyFlag_[0]) {
+            sql += "session_id,";
+            ++parametersCount;
+        }
+        if (dirtyFlag_[1]) {
+            sql += "status,";
+            ++parametersCount;
+        }
+        sql += "saved_on,";
+        ++parametersCount;
+        if (!dirtyFlag_[2]) {
+            needSelection = true;
+        }
+        if (parametersCount > 0) {
+            sql[sql.length() - 1] = ')';
+            sql += " values (";
+        } else
+            sql += ") values (";
+
+        int placeholder = 1;
+        char placeholderStr[64];
+        size_t n = 0;
+        if (dirtyFlag_[0]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[1]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[2]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        } else {
+            sql += "default,";
+        }
+        if (parametersCount > 0) {
+            sql.resize(sql.length() - 1);
+        }
+        if (needSelection) {
+            sql.append(") returning *");
+        } else {
+            sql.append(1, ')');
+        }
+        LOG_TRACE << sql;
+        return sql;
+    }
+};
+}  // namespace cavoke_orm
+}  // namespace drogon_model
diff --git a/server/sql-models/Users.cc b/server/sql-models/Users.cc
new file mode 100644
index 00000000..5e90b821
--- /dev/null
+++ b/server/sql-models/Users.cc
@@ -0,0 +1,440 @@
+/**
+ *
+ *  Users.cc
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#include "Users.h"
+#include <drogon/utils/Utilities.h>
+#include <string>
+#include "Players.h"
+#include "RoomJoins.h"
+
+using namespace drogon;
+using namespace drogon::orm;
+using namespace drogon_model::cavoke_orm;
+
+const std::string Users::Cols::_id = "id";
+const std::string Users::Cols::_display_name = "display_name";
+const std::string Users::primaryKeyName = "id";
+const bool Users::hasPrimaryKey = true;
+const std::string Users::tableName = "users";
+
+const std::vector<typename Users::MetaData> Users::metaData_ = {
+    {"id", "std::string", "character varying", 0, 0, 1, 1},
+    {"display_name", "std::string", "character varying", 0, 0, 0, 0}};
+const std::string &Users::getColumnName(size_t index) noexcept(false) {
+    assert(index < metaData_.size());
+    return metaData_[index].colName_;
+}
+Users::Users(const Row &r, const ssize_t indexOffset) noexcept {
+    if (indexOffset < 0) {
+        if (!r["id"].isNull()) {
+            id_ = std::make_shared<std::string>(r["id"].as<std::string>());
+        }
+        if (!r["display_name"].isNull()) {
+            displayName_ = std::make_shared<std::string>(
+                r["display_name"].as<std::string>());
+        }
+    } else {
+        size_t offset = (size_t)indexOffset;
+        if (offset + 2 > r.size()) {
+            LOG_FATAL << "Invalid SQL result for this model";
+            return;
+        }
+        size_t index;
+        index = offset + 0;
+        if (!r[index].isNull()) {
+            id_ = std::make_shared<std::string>(r[index].as<std::string>());
+        }
+        index = offset + 1;
+        if (!r[index].isNull()) {
+            displayName_ =
+                std::make_shared<std::string>(r[index].as<std::string>());
+        }
+    }
+}
+
+Users::Users(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 2) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        dirtyFlag_[0] = true;
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            id_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            displayName_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+}
+
+Users::Users(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("id")) {
+        dirtyFlag_[0] = true;
+        if (!pJson["id"].isNull()) {
+            id_ = std::make_shared<std::string>(pJson["id"].asString());
+        }
+    }
+    if (pJson.isMember("display_name")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["display_name"].isNull()) {
+            displayName_ =
+                std::make_shared<std::string>(pJson["display_name"].asString());
+        }
+    }
+}
+
+void Users::updateByMasqueradedJson(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector) noexcept(false) {
+    if (pMasqueradingVector.size() != 2) {
+        LOG_ERROR << "Bad masquerading vector";
+        return;
+    }
+    if (!pMasqueradingVector[0].empty() &&
+        pJson.isMember(pMasqueradingVector[0])) {
+        if (!pJson[pMasqueradingVector[0]].isNull()) {
+            id_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[0]].asString());
+        }
+    }
+    if (!pMasqueradingVector[1].empty() &&
+        pJson.isMember(pMasqueradingVector[1])) {
+        dirtyFlag_[1] = true;
+        if (!pJson[pMasqueradingVector[1]].isNull()) {
+            displayName_ = std::make_shared<std::string>(
+                pJson[pMasqueradingVector[1]].asString());
+        }
+    }
+}
+
+void Users::updateByJson(const Json::Value &pJson) noexcept(false) {
+    if (pJson.isMember("id")) {
+        if (!pJson["id"].isNull()) {
+            id_ = std::make_shared<std::string>(pJson["id"].asString());
+        }
+    }
+    if (pJson.isMember("display_name")) {
+        dirtyFlag_[1] = true;
+        if (!pJson["display_name"].isNull()) {
+            displayName_ =
+                std::make_shared<std::string>(pJson["display_name"].asString());
+        }
+    }
+}
+
+const std::string &Users::getValueOfId() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (id_)
+        return *id_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Users::getId() const noexcept {
+    return id_;
+}
+void Users::setId(const std::string &pId) noexcept {
+    id_ = std::make_shared<std::string>(pId);
+    dirtyFlag_[0] = true;
+}
+void Users::setId(std::string &&pId) noexcept {
+    id_ = std::make_shared<std::string>(std::move(pId));
+    dirtyFlag_[0] = true;
+}
+const typename Users::PrimaryKeyType &Users::getPrimaryKey() const {
+    assert(id_);
+    return *id_;
+}
+
+const std::string &Users::getValueOfDisplayName() const noexcept {
+    const static std::string defaultValue = std::string();
+    if (displayName_)
+        return *displayName_;
+    return defaultValue;
+}
+const std::shared_ptr<std::string> &Users::getDisplayName() const noexcept {
+    return displayName_;
+}
+void Users::setDisplayName(const std::string &pDisplayName) noexcept {
+    displayName_ = std::make_shared<std::string>(pDisplayName);
+    dirtyFlag_[1] = true;
+}
+void Users::setDisplayName(std::string &&pDisplayName) noexcept {
+    displayName_ = std::make_shared<std::string>(std::move(pDisplayName));
+    dirtyFlag_[1] = true;
+}
+void Users::setDisplayNameToNull() noexcept {
+    displayName_.reset();
+    dirtyFlag_[1] = true;
+}
+
+void Users::updateId(const uint64_t id) {
+}
+
+const std::vector<std::string> &Users::insertColumns() noexcept {
+    static const std::vector<std::string> inCols = {"id", "display_name"};
+    return inCols;
+}
+
+void Users::outputArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getId()) {
+            binder << getValueOfId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getDisplayName()) {
+            binder << getValueOfDisplayName();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+
+const std::vector<std::string> Users::updateColumns() const {
+    std::vector<std::string> ret;
+    if (dirtyFlag_[0]) {
+        ret.push_back(getColumnName(0));
+    }
+    if (dirtyFlag_[1]) {
+        ret.push_back(getColumnName(1));
+    }
+    return ret;
+}
+
+void Users::updateArgs(drogon::orm::internal::SqlBinder &binder) const {
+    if (dirtyFlag_[0]) {
+        if (getId()) {
+            binder << getValueOfId();
+        } else {
+            binder << nullptr;
+        }
+    }
+    if (dirtyFlag_[1]) {
+        if (getDisplayName()) {
+            binder << getValueOfDisplayName();
+        } else {
+            binder << nullptr;
+        }
+    }
+}
+Json::Value Users::toJson() const {
+    Json::Value ret;
+    if (getId()) {
+        ret["id"] = getValueOfId();
+    } else {
+        ret["id"] = Json::Value();
+    }
+    if (getDisplayName()) {
+        ret["display_name"] = getValueOfDisplayName();
+    } else {
+        ret["display_name"] = Json::Value();
+    }
+    return ret;
+}
+
+Json::Value Users::toMasqueradedJson(
+    const std::vector<std::string> &pMasqueradingVector) const {
+    Json::Value ret;
+    if (pMasqueradingVector.size() == 2) {
+        if (!pMasqueradingVector[0].empty()) {
+            if (getId()) {
+                ret[pMasqueradingVector[0]] = getValueOfId();
+            } else {
+                ret[pMasqueradingVector[0]] = Json::Value();
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (getDisplayName()) {
+                ret[pMasqueradingVector[1]] = getValueOfDisplayName();
+            } else {
+                ret[pMasqueradingVector[1]] = Json::Value();
+            }
+        }
+        return ret;
+    }
+    LOG_ERROR << "Masquerade failed";
+    if (getId()) {
+        ret["id"] = getValueOfId();
+    } else {
+        ret["id"] = Json::Value();
+    }
+    if (getDisplayName()) {
+        ret["display_name"] = getValueOfDisplayName();
+    } else {
+        ret["display_name"] = Json::Value();
+    }
+    return ret;
+}
+
+bool Users::validateJsonForCreation(const Json::Value &pJson,
+                                    std::string &err) {
+    if (pJson.isMember("id")) {
+        if (!validJsonOfField(0, "id", pJson["id"], err, true))
+            return false;
+    } else {
+        err = "The id column cannot be null";
+        return false;
+    }
+    if (pJson.isMember("display_name")) {
+        if (!validJsonOfField(1, "display_name", pJson["display_name"], err,
+                              true))
+            return false;
+    }
+    return true;
+}
+bool Users::validateMasqueradedJsonForCreation(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 2) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty()) {
+            if (pJson.isMember(pMasqueradingVector[0])) {
+                if (!validJsonOfField(0, pMasqueradingVector[0],
+                                      pJson[pMasqueradingVector[0]], err, true))
+                    return false;
+            } else {
+                err =
+                    "The " + pMasqueradingVector[0] + " column cannot be null";
+                return false;
+            }
+        }
+        if (!pMasqueradingVector[1].empty()) {
+            if (pJson.isMember(pMasqueradingVector[1])) {
+                if (!validJsonOfField(1, pMasqueradingVector[1],
+                                      pJson[pMasqueradingVector[1]], err, true))
+                    return false;
+            }
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Users::validateJsonForUpdate(const Json::Value &pJson, std::string &err) {
+    if (pJson.isMember("id")) {
+        if (!validJsonOfField(0, "id", pJson["id"], err, false))
+            return false;
+    } else {
+        err =
+            "The value of primary key must be set in the json object for "
+            "update";
+        return false;
+    }
+    if (pJson.isMember("display_name")) {
+        if (!validJsonOfField(1, "display_name", pJson["display_name"], err,
+                              false))
+            return false;
+    }
+    return true;
+}
+bool Users::validateMasqueradedJsonForUpdate(
+    const Json::Value &pJson,
+    const std::vector<std::string> &pMasqueradingVector,
+    std::string &err) {
+    if (pMasqueradingVector.size() != 2) {
+        err = "Bad masquerading vector";
+        return false;
+    }
+    try {
+        if (!pMasqueradingVector[0].empty() &&
+            pJson.isMember(pMasqueradingVector[0])) {
+            if (!validJsonOfField(0, pMasqueradingVector[0],
+                                  pJson[pMasqueradingVector[0]], err, false))
+                return false;
+        } else {
+            err =
+                "The value of primary key must be set in the json object for "
+                "update";
+            return false;
+        }
+        if (!pMasqueradingVector[1].empty() &&
+            pJson.isMember(pMasqueradingVector[1])) {
+            if (!validJsonOfField(1, pMasqueradingVector[1],
+                                  pJson[pMasqueradingVector[1]], err, false))
+                return false;
+        }
+    } catch (const Json::LogicError &e) {
+        err = e.what();
+        return false;
+    }
+    return true;
+}
+bool Users::validJsonOfField(size_t index,
+                             const std::string &fieldName,
+                             const Json::Value &pJson,
+                             std::string &err,
+                             bool isForCreation) {
+    switch (index) {
+        case 0:
+            if (pJson.isNull()) {
+                err = "The " + fieldName + " column cannot be null";
+                return false;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        case 1:
+            if (pJson.isNull()) {
+                return true;
+            }
+            if (!pJson.isString()) {
+                err = "Type error in the " + fieldName + " field";
+                return false;
+            }
+            break;
+        default:
+            err = "Internal error in the server";
+            return false;
+            break;
+    }
+    return true;
+}
+void Users::getPlayers(const DbClientPtr &clientPtr,
+                       const std::function<void(std::vector<Players>)> &rcb,
+                       const ExceptionCallback &ecb) const {
+    const static std::string sql = "select * from players where user_id = $1";
+    *clientPtr << sql << *id_ >> [rcb = std::move(rcb)](const Result &r) {
+        std::vector<Players> ret;
+        ret.reserve(r.size());
+        for (auto const &row : r) {
+            ret.emplace_back(Players(row));
+        }
+        rcb(ret);
+    } >> ecb;
+}
+void Users::getRoomJoins(const DbClientPtr &clientPtr,
+                         const std::function<void(std::vector<RoomJoins>)> &rcb,
+                         const ExceptionCallback &ecb) const {
+    const static std::string sql =
+        "select * from room_joins where user_id = $1";
+    *clientPtr << sql << *id_ >> [rcb = std::move(rcb)](const Result &r) {
+        std::vector<RoomJoins> ret;
+        ret.reserve(r.size());
+        for (auto const &row : r) {
+            ret.emplace_back(RoomJoins(row));
+        }
+        rcb(ret);
+    } >> ecb;
+}
diff --git a/server/sql-models/Users.h b/server/sql-models/Users.h
new file mode 100644
index 00000000..00ddf6d0
--- /dev/null
+++ b/server/sql-models/Users.h
@@ -0,0 +1,222 @@
+/**
+ *
+ *  Users.h
+ *  DO NOT EDIT. This file is generated by drogon_ctl
+ *
+ */
+
+#pragma once
+#include <drogon/orm/Field.h>
+#include <drogon/orm/Mapper.h>
+#include <drogon/orm/Result.h>
+#include <drogon/orm/Row.h>
+#include <drogon/orm/SqlBinder.h>
+#ifdef __cpp_impl_coroutine
+#include <drogon/orm/CoroMapper.h>
+#endif
+#include <json/json.h>
+#include <stdint.h>
+#include <trantor/utils/Date.h>
+#include <trantor/utils/Logger.h>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+namespace drogon {
+namespace orm {
+class DbClient;
+using DbClientPtr = std::shared_ptr<DbClient>;
+}  // namespace orm
+}  // namespace drogon
+namespace drogon_model {
+namespace cavoke_orm {
+class Players;
+class RoomJoins;
+
+class Users {
+public:
+    struct Cols {
+        static const std::string _id;
+        static const std::string _display_name;
+    };
+
+    const static int primaryKeyNumber;
+    const static std::string tableName;
+    const static bool hasPrimaryKey;
+    const static std::string primaryKeyName;
+    using PrimaryKeyType = std::string;
+    const PrimaryKeyType &getPrimaryKey() const;
+
+    /**
+     * @brief constructor
+     * @param r One row of records in the SQL query result.
+     * @param indexOffset Set the offset to -1 to access all columns by column
+     * names, otherwise access all columns by offsets.
+     * @note If the SQL is not a style of 'select * from table_name ...' (select
+     * all columns by an asterisk), please set the offset to -1.
+     */
+    explicit Users(const drogon::orm::Row &r,
+                   const ssize_t indexOffset = 0) noexcept;
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     */
+    explicit Users(const Json::Value &pJson) noexcept(false);
+
+    /**
+     * @brief constructor
+     * @param pJson The json object to construct a new instance.
+     * @param pMasqueradingVector The aliases of table columns.
+     */
+    Users(const Json::Value &pJson,
+          const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+
+    Users() = default;
+
+    void updateByJson(const Json::Value &pJson) noexcept(false);
+    void updateByMasqueradedJson(
+        const Json::Value &pJson,
+        const std::vector<std::string> &pMasqueradingVector) noexcept(false);
+    static bool validateJsonForCreation(const Json::Value &pJson,
+                                        std::string &err);
+    static bool validateMasqueradedJsonForCreation(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validateJsonForUpdate(const Json::Value &pJson,
+                                      std::string &err);
+    static bool validateMasqueradedJsonForUpdate(
+        const Json::Value &,
+        const std::vector<std::string> &pMasqueradingVector,
+        std::string &err);
+    static bool validJsonOfField(size_t index,
+                                 const std::string &fieldName,
+                                 const Json::Value &pJson,
+                                 std::string &err,
+                                 bool isForCreation);
+
+    /**  For column id  */
+    /// Get the value of the column id, returns the default value if the column
+    /// is null
+    const std::string &getValueOfId() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getId() const noexcept;
+    /// Set the value of the column id
+    void setId(const std::string &pId) noexcept;
+    void setId(std::string &&pId) noexcept;
+
+    /**  For column display_name  */
+    /// Get the value of the column display_name, returns the default value if
+    /// the column is null
+    const std::string &getValueOfDisplayName() const noexcept;
+    /// Return a shared_ptr object pointing to the column const value, or an
+    /// empty shared_ptr object if the column is null
+    const std::shared_ptr<std::string> &getDisplayName() const noexcept;
+    /// Set the value of the column display_name
+    void setDisplayName(const std::string &pDisplayName) noexcept;
+    void setDisplayName(std::string &&pDisplayName) noexcept;
+    void setDisplayNameToNull() noexcept;
+
+    static size_t getColumnNumber() noexcept {
+        return 2;
+    }
+    static const std::string &getColumnName(size_t index) noexcept(false);
+
+    Json::Value toJson() const;
+    Json::Value toMasqueradedJson(
+        const std::vector<std::string> &pMasqueradingVector) const;
+    /// Relationship interfaces
+    void getPlayers(const drogon::orm::DbClientPtr &clientPtr,
+                    const std::function<void(std::vector<Players>)> &rcb,
+                    const drogon::orm::ExceptionCallback &ecb) const;
+    void getRoomJoins(const drogon::orm::DbClientPtr &clientPtr,
+                      const std::function<void(std::vector<RoomJoins>)> &rcb,
+                      const drogon::orm::ExceptionCallback &ecb) const;
+
+private:
+    friend drogon::orm::Mapper<Users>;
+#ifdef __cpp_impl_coroutine
+    friend drogon::orm::CoroMapper<Users>;
+#endif
+    static const std::vector<std::string> &insertColumns() noexcept;
+    void outputArgs(drogon::orm::internal::SqlBinder &binder) const;
+    const std::vector<std::string> updateColumns() const;
+    void updateArgs(drogon::orm::internal::SqlBinder &binder) const;
+    /// For mysql or sqlite3
+    void updateId(const uint64_t id);
+    std::shared_ptr<std::string> id_;
+    std::shared_ptr<std::string> displayName_;
+    struct MetaData {
+        const std::string colName_;
+        const std::string colType_;
+        const std::string colDatabaseType_;
+        const ssize_t colLength_;
+        const bool isAutoVal_;
+        const bool isPrimaryKey_;
+        const bool notNull_;
+    };
+    static const std::vector<MetaData> metaData_;
+    bool dirtyFlag_[2] = {false};
+
+public:
+    static const std::string &sqlForFindingByPrimaryKey() {
+        static const std::string sql =
+            "select * from " + tableName + " where id = $1";
+        return sql;
+    }
+
+    static const std::string &sqlForDeletingByPrimaryKey() {
+        static const std::string sql =
+            "delete from " + tableName + " where id = $1";
+        return sql;
+    }
+    std::string sqlForInserting(bool &needSelection) const {
+        std::string sql = "insert into " + tableName + " (";
+        size_t parametersCount = 0;
+        needSelection = false;
+        if (dirtyFlag_[0]) {
+            sql += "id,";
+            ++parametersCount;
+        }
+        sql += "display_name,";
+        ++parametersCount;
+        if (!dirtyFlag_[1]) {
+            needSelection = true;
+        }
+        if (parametersCount > 0) {
+            sql[sql.length() - 1] = ')';
+            sql += " values (";
+        } else
+            sql += ") values (";
+
+        int placeholder = 1;
+        char placeholderStr[64];
+        size_t n = 0;
+        if (dirtyFlag_[0]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        }
+        if (dirtyFlag_[1]) {
+            n = sprintf(placeholderStr, "$%d,", placeholder++);
+            sql.append(placeholderStr, n);
+        } else {
+            sql += "default,";
+        }
+        if (parametersCount > 0) {
+            sql.resize(sql.length() - 1);
+        }
+        if (needSelection) {
+            sql.append(") returning *");
+        } else {
+            sql.append(1, ')');
+        }
+        LOG_TRACE << sql;
+        return sql;
+    }
+};
+}  // namespace cavoke_orm
+}  // namespace drogon_model
diff --git a/server/sql-models/model.json b/server/sql-models/model.json
new file mode 100644
index 00000000..f80a3fda
--- /dev/null
+++ b/server/sql-models/model.json
@@ -0,0 +1,68 @@
+{
+  //rdbms: server type, postgresql,mysql or sqlite3
+  "rdbms": "postgresql",
+  //filename: sqlite3 db file name
+  //"filename":"",
+  //host: server address,localhost by default;
+  "host": "127.0.0.1",
+  //port: server port, 5432 by default;
+  "port": 5432,
+  //dbname: Database name;
+  "dbname": "cavoke",
+  //schema: valid for postgreSQL, "public" by default;
+  "schema": "public",
+  //user: User name
+  "user": "postgres",
+  //password or passwd: Password
+  "password": "local",
+  //client_encoding: The character set used by drogon_ctl. it is empty string by default which
+  //means use the default character set.
+  //"client_encoding": "",
+  //table: An array of tables to be modelized. if the array is empty, all revealed tables are modelized.
+  "tables": [],
+  "relationships": {
+    "enabled": true,
+    "items": [
+      {
+        "type": "has many",
+        "original_table_name": "sessions",
+        "original_table_alias": "Session",
+        "original_key": "id",
+        "target_table_name": "players",
+        "target_table_alias": "",
+        "target_key": "session_id",
+        "enable_reverse": true
+      },
+      {
+        "type": "has many",
+        "original_table_name": "users",
+        "original_table_alias": "User",
+        "original_key": "id",
+        "target_table_name": "players",
+        "target_table_alias": "",
+        "target_key": "user_id",
+        "enable_reverse": true
+      },
+      {
+        "type": "has many",
+        "original_table_name": "rooms",
+        "original_table_alias": "Room",
+        "original_key": "id",
+        "target_table_name": "room_joins",
+        "target_table_alias": "",
+        "target_key": "room_id",
+        "enable_reverse": true
+      },
+      {
+        "type": "has many",
+        "original_table_name": "users",
+        "original_table_alias": "User",
+        "original_key": "id",
+        "target_table_name": "room_joins",
+        "target_table_alias": "",
+        "target_key": "user_id",
+        "enable_reverse": true
+      }
+    ]
+  }
+}
diff --git a/server/test/CMakeLists.txt b/server/test/CMakeLists.txt
new file mode 100644
index 00000000..cc4c335b
--- /dev/null
+++ b/server/test/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.10)
+project(cavoke_server_test CXX)
+
+add_executable(${PROJECT_NAME} test_main.cc)
+
+# ##############################################################################
+# If you include the drogon source code locally in your project, use this method
+# to add drogon 
+# target_link_libraries(${PROJECT_NAME}_test PRIVATE drogon)
+#
+# and comment out the following lines
+if (USE_EXTERNAL_DROGON)
+    target_link_libraries(${PROJECT_NAME} PRIVATE Drogon::Drogon)
+else ()
+    target_link_libraries(${PROJECT_NAME} PRIVATE drogon)
+endif ()
+
+ParseAndAddDrogonTests(${PROJECT_NAME})
diff --git a/server/test/test_main.cc b/server/test/test_main.cc
new file mode 100644
index 00000000..ceb04fda
--- /dev/null
+++ b/server/test/test_main.cc
@@ -0,0 +1,30 @@
+#define DROGON_TEST_MAIN
+#include <drogon/drogon.h>
+#include <drogon/drogon_test.h>
+
+DROGON_TEST(BasicTest) {
+    // Add your tests here
+}
+
+int main(int argc, char **argv) {
+    using namespace drogon;
+
+    std::promise<void> p1;
+    std::future<void> f1 = p1.get_future();
+
+    // Start the main loop on another thread
+    std::thread thr([&]() {
+        // Queues the promise to be fulfilled after starting the loop
+        app().getLoop()->queueInLoop([&p1]() { p1.set_value(); });
+        app().run();
+    });
+
+    // The future is only satisfied after the event loop started
+    f1.get();
+    int status = test::run(argc, argv);
+
+    // Ask the event loop to shutdown and wait
+    app().getLoop()->queueInLoop([]() { app().quit(); });
+    thr.join();
+    return status;
+}
diff --git a/server/utils.h b/server/utils.h
index 5c5c346a..022c0617 100644
--- a/server/utils.h
+++ b/server/utils.h
@@ -2,8 +2,10 @@
 #define CAVOKE_UTILS_H
 
 #include <drogon/HttpResponse.h>
+#include <json/json.h>
 #include <boost/filesystem/path.hpp>
 #include <nlohmann/json.hpp>
+#include <regex>
 #include "cavoke_base_exception.h"
 
 namespace nlohmann {
@@ -18,6 +20,11 @@ struct adl_serializer<boost::filesystem::path> {
         value = j.get<std::string>();
     }
 };
+
+inline nlohmann::json to_nlohmann(const Json::Value &obj) {
+    static Json::StreamWriterBuilder builder;
+    return json::parse(Json::writeString(builder, obj), nullptr, true, true);
+}
 }  // namespace nlohmann
 
 namespace cavoke::server::controllers {
@@ -57,4 +64,18 @@ inline drogon::HttpResponsePtr newCavokeErrorResponse(
     callback(newStatusCodeResponse(::drogon::code))
 }  // namespace cavoke::server::controllers
 
+namespace cavoke::server {
+/// Hides password from sql connection info
+inline std::string hide_password(std::string str) {
+    return std::regex_replace(str, std::regex(R"(\b[^\s]*pass[^\s]*\b)"),
+                              R"(<pass hidden>)");
+}
+}  // namespace cavoke::server
+
+#define MAPPER_TYPE(T) ::drogon::orm::Mapper<T>
+/// ORM mapper for given database client (e.g. transaction dbclient)
+#define MAPPER_WITH_CLIENT_FOR(T, dbclient) MAPPER_TYPE(T)(dbclient)
+/// ORM mapper for default database client
+#define MAPPER_FOR(T) MAPPER_WITH_CLIENT_FOR(T, drogon::app().getDbClient())
+
 #endif  // CAVOKE_UTILS_H
diff --git a/third_party/drogon b/third_party/drogon
new file mode 160000
index 00000000..f017b099
--- /dev/null
+++ b/third_party/drogon
@@ -0,0 +1 @@
+Subproject commit f017b09947badc2e0516355358c8eb7843b44e19
diff --git a/third_party/extra-cmake-modules b/third_party/extra-cmake-modules
new file mode 160000
index 00000000..b6c8b20c
--- /dev/null
+++ b/third_party/extra-cmake-modules
@@ -0,0 +1 @@
+Subproject commit b6c8b20c1047006f148a9376046e45e8f036b3bd
diff --git a/third_party/json b/third_party/json
new file mode 160000
index 00000000..b205361d
--- /dev/null
+++ b/third_party/json
@@ -0,0 +1 @@
+Subproject commit b205361d8652759b6d850a37b227c8d57ee19005
diff --git a/third_party/jwt b/third_party/jwt
new file mode 160000
index 00000000..5c588fcc
--- /dev/null
+++ b/third_party/jwt
@@ -0,0 +1 @@
+Subproject commit 5c588fccd67545b5bbe1d7653963034d0151742a
diff --git a/third_party/karchive b/third_party/karchive
new file mode 160000
index 00000000..f63a2ba2
--- /dev/null
+++ b/third_party/karchive
@@ -0,0 +1 @@
+Subproject commit f63a2ba291c9ec88ce84d0c5b890a51f9308b1f2
diff --git a/third_party/qtkeychain b/third_party/qtkeychain
new file mode 160000
index 00000000..e5eeb176
--- /dev/null
+++ b/third_party/qtkeychain
@@ -0,0 +1 @@
+Subproject commit e5eeb1763e295f6b05a3f008ee7ae192fd74ed0c
diff --git a/third_party/zlib b/third_party/zlib
new file mode 160000
index 00000000..21767c65
--- /dev/null
+++ b/third_party/zlib
@@ -0,0 +1 @@
+Subproject commit 21767c654d31d2dccdde4330529775c6c5fd5389