Always set game status change timestamp to now instead of game's last updated_at

Prevents actually finding any new prices

.devcontainer/devcontainer.json

@@ -0,0 +1,25 @@
+{
+  "name": "Django Time Tracker",
+  "dockerFile": "../devcontainer.Dockerfile",
+  "customizations": {
+    "vscode": {
+      "settings": {
+        "python.pythonPath": "/usr/local/bin/python",
+        "python.defaultInterpreterPath": "/usr/local/bin/python",
+        "terminal.integrated.defaultProfile.linux": "bash"
+      },
+      "extensions": [
+        "ms-python.python",
+        "ms-python.debugpy",
+        "ms-python.vscode-pylance",
+        "ms-azuretools.vscode-docker",
+        "batisteo.vscode-django",
+        "charliermarsh.ruff",
+        "bradlc.vscode-tailwindcss",
+        "EditorConfig.EditorConfig"
+      ]
+    }
+  },
+  "forwardPorts": [8000],
+  "postCreateCommand": "poetry install && poetry run python manage.py migrate && npm install && make dev",
+}

.dockerignore

@@ -5,4 +5,13 @@
 .venv
 .vscode
 node_modules
-src/timetracker/static/*
+static
+.drone.yml
+.editorconfig
+.gitignore
+Caddyfile
+CHANGELOG.md
+db.sqlite3
+docker-compose*
+Dockerfile
+Makefile

.drone.yml

@@ -5,23 +5,28 @@ name: default
 
 steps:
 - name: test
-  image: python:3.10
+  image: python:3.12
   commands:
     - python -m pip install poetry
     - poetry install
     - poetry env info
+    - poetry run python manage.py migrate
     - poetry run pytest
-- name: build container (prod)
+
+- name: build-prod
   image: plugins/docker
   settings:
     repo: registry.kucharczyk.xyz/timetracker
     tags:
       - latest
+      - 1.1.0
+  depends_on:
+    - "test"
   when:
     branch:
       - main
 
-- name: build container (non-prod)
+- name: build-non-prod
   image: plugins/docker
   settings:
     repo: registry.kucharczyk.xyz/timetracker
@@ -32,9 +37,20 @@ steps:
     branch:
       exclude:
         - main
+  depends_on:
+    - "test"
+
+- name: redeploy on portainer
+  image: plugins/webhook
+  settings:
+    urls:
+      from_secret: PORTAINER_TIMETRACKER_WEBHOOK_URL
+  depends_on:
+    - "build-prod"
+    
     
     
 trigger:
   event:
   - push
-  - cron
+  - cron

.editorconfig

@@ -0,0 +1,20 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+
+[*.{js,py}]
+charset = utf-8
+
+# 4 space indentation
+[*.py]
+indent_style = space
+indent_size = 4
+
+[**/*.js]
+indent_style = space
+indent_size = 2
+
+[*.html]
+insert_final_newline = false

.envrc

@@ -0,0 +1 @@
+use nix

.github/workflows/build-docker.yml

@@ -0,0 +1,36 @@
+name: Django CI/CD
+
+on:
+  push:
+    paths-ignore: [ 'README.md' ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: 3.12
+      - run: |
+          python -m pip install poetry
+          poetry install
+          poetry env info
+          poetry run python manage.py migrate
+          # PROD=1 poetry run pytest
+  build-and-push:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+    steps:
+      - uses: actions/checkout@v4
+      - uses: docker/setup-buildx-action@v3
+      - uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: |
+            registry.kucharczyk.xyz/timetracker:latest
+            registry.kucharczyk.xyz/timetracker:${{ env.VERSION_NUMBER }}          
+    env:
+      VERSION_NUMBER: 1.5.1

.gitignore

@@ -1,9 +1,12 @@
 __pycache__
 .mypy_cache
 .pytest_cache
-.venv
+.venv/
 node_modules
 package-lock.json
 db.sqlite3
-static
-dist/
+/static/
+dist/
+.DS_Store
+.python-version
+.direnv

.vscode/extensions.json

@@ -0,0 +1,11 @@
+{
+    "recommendations": [
+        "charliermarsh.ruff",
+        "ms-python.python",
+        "ms-python.vscode-pylance",
+        "ms-python.debugpy",
+        "batisteo.vscode-django",
+        "bradlc.vscode-tailwindcss",
+        "EditorConfig.EditorConfig"
+    ]
+}

.vscode/launch.json

@@ -0,0 +1,26 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "Python Debugger: Current File",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "${file}",
+            "console": "integratedTerminal"
+        },
+        {
+            "name": "Python Debugger: Django",
+            "type": "debugpy",
+            "request": "launch",
+            "args": [
+                "runserver"
+            ],
+            "django": true,
+            "autoStartBrowser": false,
+            "program": "${workspaceFolder}/manage.py"
+        }
+    ]
+}

.vscode/settings.json

@@ -4,5 +4,30 @@
     ],
     "python.testing.unittestEnabled": false,
     "python.testing.pytestEnabled": true,
-    "python.analysis.typeCheckingMode": "basic"
-}
+    "python.analysis.typeCheckingMode": "strict",
+    "[python]": {
+        "editor.defaultFormatter": "charliermarsh.ruff",
+        "editor.formatOnSave": true,
+        "editor.codeActionsOnSave": {
+            "source.fixAll": "explicit",
+            "source.organizeImports": "explicit"
+        },
+    },
+    "ruff.path": ["/nix/store/jaibb3v0rrnlw5ib54qqq3452yhp1xcb-ruff-0.5.7/bin/ruff"],
+    "tailwind-fold.supportedLanguages": [
+        "html",
+        "typescriptreact",
+        "javascriptreact",
+        "typescript",
+        "javascript",
+        "vue-html",
+        "vue",
+        "php",
+        "markdown",
+        "coffeescript",
+        "svelte",
+        "astro",
+        "erb",
+        "django-html"
+    ]
+}

CHANGELOG.md

@@ -1,5 +1,172 @@
 ## Unreleased
 
+## New
+* Render notes as Markdown
+* Require login by default
+* Add stats for dropped purchases, monthly playtimes
+* Allow deleting purchases
+* Add all-time stats
+* Manage purchases
+* Automatically convert purchase prices
+* Add emulated property to sessions
+* Add today's and last 7 days playtime stats to navbar
+
+## Improved
+* mark refunded purchases red on game overview
+* increase session count on game overview when starting a new session
+* game overview:
+  * sort purchases also by date purchased (on top of date released)
+  * improve header format, make it more appealing
+  * ignore manual sessions when calculating session average
+* stats: improve purchase name consistency
+* session list: use display name instead of sort name
+* unify the appearance of game links, and make them expand to full size on hover
+
+## Fixed
+* Fix title not being displayed on the Recent sessions page
+* Avoid errors when displaying game overview with zero sessions
+
+## 1.5.2 / 2024-01-14 21:27+01:00
+
+## Improved
+* game overview:
+  * improve how editions and purchases are displayed
+  * make it possible to end session from overview
+* add purchase: only allow choosing purchases of selected edition
+* session list:
+  * starting and ending sessions is much faster/doest not reload the page
+  * listing sessions is much faster
+
+## 1.5.1 / 2023-11-14 21:10+01:00
+
+## Improved
+* Disallow choosing non-game purchase as related purchase
+* Improve display of purchases
+
+## 1.5.0 / 2023-11-14 19:27+01:00
+
+## New
+* Add stat for finished this year's games
+* Add purchase types:
+  * Game (previously all of them were this type)
+  * DLC
+  * Season Pass
+  * Battle Pass
+
+## Fixed
+* Order purchases by date on game view
+
+## 1.4.0 / 2023-11-09 21:01+01:00
+
+### New
+* More fields are now optional. This is to make it easier to add new items in bulk.
+  * Game: Wikidata ID
+  * Edition: Platform, Year
+  * Purchase: Platform
+  * Platform: Group
+  * Session: Device
+* New fields:
+  * Game: Year Released
+    * To record original year of release
+    * Upon migration, this will be set to a year of any of the game's edition that has it set
+  * Purchase: Date Finished
+* Editions are now unique combination of name and platform
+* Add more stats:
+  * All finished games
+  * All finished 2023 games
+  * All finished games that were purchased this year
+  * Sessions (count)
+  * Days played
+  * Finished (count)
+  * Unfinished (count)
+  * Refunded (count)
+  * Backlog Decrease (count)
+* New workflow:
+  * Adding Game, Edition, Purchase, and Session in a row is now much faster
+
+### Improved
+* game overview: simplify playtime range display
+* new session: order devices alphabetically
+* ignore English articles when sorting names
+  * added a new sort_name field that gets automatically created
+* automatically fill certain values in forms:
+  * new game: name and sort name after typing
+  * new edition: name, sort name, and year when selecting game
+  * new purchase: platform when selecting edition
+
+## 1.3.0 / 2023-11-05 15:09+01:00
+
+### New
+* Add Stats to the main navigation
+* Allow selecting year on the Stats page
+
+### Improved
+* Make some pages redirect back instead to session list
+
+### Improved
+* Make navigation more compact
+
+### Fixed
+* Correctly limit sessions to a single year for stats
+
+## 1.2.0 / 2023-11-01 20:18+01:00
+
+### New
+* Add yearly stats page (https://git.kucharczyk.xyz/lukas/timetracker/issues/15)
+
+### Enhancements
+* Add a button to start session from game overview
+
+## 1.1.2 / 2023-10-13 16:30+02:00
+
+### Enhancements
+* Durations are formatted in a consisent manner across all pages
+
+### Fixes
+* Game Overview: display duration when >1 hour instead of displaying 0
+
+## 1.1.1 / 2023-10-09 20:52+02:00
+
+### New
+* Add notes section to game overview
+
+### Enhancements
+* Make it possible to add any data on the game overview page
+
+## 1.1.0 / 2023-10-09 00:01+02:00
+
+### New
+* Add game overview page (https://git.kucharczyk.xyz/lukas/timetracker/issues/8)
+* Add helper buttons next to datime fields
+* Add copy button on Add session page to copy times between fields
+* Change fonts to IBM Plex
+
+### Enhancements
+* Improve form appearance
+* Focus important fields on forms
+* Use the same form when editing a session as when adding a session
+* Change recent session view to current year instead of last 30 days
+* Add a hacky way not to reload a page when starting or ending a session (https://git.kucharczyk.xyz/lukas/timetracker/issues/52)
+* Improve session list (https://git.kucharczyk.xyz/lukas/timetracker/issues/53)
+
+### Fixes
+
+* Fix session being wrongly considered in progress if it had a certain amount of manual hours (https://git.kucharczyk.xyz/lukas/timetracker/issues/58)
+* Fix bug when filtering only manual sessions (https://git.kucharczyk.xyz/lukas/timetracker/issues/51)
+
+
+## 1.0.3 / 2023-02-20 17:16+01:00
+
+* Add wikidata ID and year for editions
+* Add icons for game, edition, purchase filters
+* Allow filtering by game, edition, purchase from the session list
+* Allow editing filtered entities from session list
+
+## 1.0.2 / 2023-02-18 21:48+01:00
+
+* Add support for device info (https://git.kucharczyk.xyz/lukas/timetracker/issues/49)
+* Add support for purchase ownership information (https://git.kucharczyk.xyz/lukas/timetracker/issues/48)
+* Add support for purchase prices
 * Add support for game editions (https://git.kucharczyk.xyz/lukas/timetracker/issues/28)
 
 ## 1.0.1 / 2023-01-30 22:17+01:00

Dockerfile

@@ -1,34 +1,45 @@
-FROM node as css
-WORKDIR /app
-COPY . /app
-RUN npm install && \
-    npx tailwindcss -i ./common/input.css -o ./static/base.css --minify
+FROM python:3.12.0-slim-bullseye
 
-FROM python:3.10.9-slim-bullseye
+ENV VERSION_NUMBER=1.5.2 \
+    PROD=1 \
+    PYTHONUNBUFFERED=1 \
+    PYTHONFAULTHANDLER=1 \
+    PYTHONHASHSEED=random \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    PIP_DEFAULT_TIMEOUT=100 \
+    PIP_ROOT_USER_ACTION=ignore \
+    POETRY_NO_INTERACTION=1 \
+    POETRY_VIRTUALENVS_CREATE=false \
+    POETRY_CACHE_DIR='/var/cache/pypoetry' \
+    POETRY_HOME='/usr/local'
 
-ENV VERSION_NUMBER 1.0.0
-ENV PROD 1
-ENV PYTHONUNBUFFERED=1
-
-RUN apt update && \
-    apt install -y \
+RUN apt-get update && apt-get upgrade -y \
+  && apt-get install --no-install-recommends -y \
     bash \
-    vim \
-    curl && \
-    rm -rf /var/lib/apt/lists/*
+    curl \
+  && curl -sSL 'https://install.python-poetry.org' | python - \
+  && poetry --version \
+  && apt-get purge -y --auto-remove -o APT::AutoRemove::RecommendsImportant=false \
+  && apt-get clean -y && rm -rf /var/lib/apt/lists/*
 
-RUN useradd -m --uid 1000 timetracker
+RUN useradd -m --uid 1000 timetracker \
+    && mkdir -p '/var/www/django/static' \
+    && chown timetracker:timetracker '/var/www/django/static'
 WORKDIR /home/timetracker/app
 COPY . /home/timetracker/app/
 RUN chown -R timetracker:timetracker /home/timetracker/app
-COPY --from=css ./app/static/base.css /home/timetracker/app/static/base.css
 COPY entrypoint.sh /
 RUN chmod +x /entrypoint.sh
 
+RUN --mount=type=cache,target="$POETRY_CACHE_DIR" \
+    echo "$PROD" \
+    && poetry version \
+    && poetry run pip install -U pip \
+    && poetry install --only main --no-interaction --no-ansi --sync
+
 USER timetracker
-ENV PATH="$PATH:/home/timetracker/.local/bin"
-RUN pip install --no-cache-dir poetry
-RUN poetry install --without dev
 
 EXPOSE 8000
-CMD [ "/entrypoint.sh" ]
+CMD [ "/entrypoint.sh" ]

Makefile

@@ -3,6 +3,7 @@ all: css migrate
 initialize: npm css migrate sethookdir loadplatforms
 
 HTMLFILES := $(shell find games/templates -type f)
+PYTHON_VERSION = 3.12
 
 npm:
 	npm install
@@ -10,17 +11,26 @@ npm:
 css: common/input.css
 	npx tailwindcss -i ./common/input.css -o  ./games/static/base.css
 
-css-dev: css
-	npx tailwindcss -i ./common/input.css -o  ./games/static/base.css --watch
-
 makemigrations:
 	poetry run python manage.py makemigrations
 
 migrate: makemigrations
 	poetry run python manage.py migrate
 
-dev: migrate
-	poetry run python manage.py runserver
+init:
+	pyenv install -s $(PYTHON_VERSION)
+	pyenv local $(PYTHON_VERSION)
+	pip install poetry
+	poetry install
+	npm install
+
+dev:
+	@npx concurrently \
+		--names "Django,Tailwind" \
+		--prefix-colors "blue,green" \
+		"poetry run python -Wa manage.py runserver" \
+		"npx tailwindcss -i ./common/input.css -o ./games/static/base.css --watch"
+
 
 caddy:
 	caddy run --watch

README.md

@@ -1,3 +1,15 @@
 # Timetracker
 
-A simple game catalogue and play session tracker.
+A simple game catalogue and play session tracker.
+
+# Development
+
+The project uses `pyenv` to manage installed Python versions.
+If you have `pyenv` installed, you can simply run:
+
+```
+make init
+```
+
+This will make sure the correct Python version is installed, and it will install all dependencies using `poetry`.
+Afterwards, you can start the development server using `make dev`.

common/components.py

@@ -0,0 +1,287 @@
+from random import choices as random_choices
+from string import ascii_lowercase
+from typing import Any, Callable
+
+from django.template import TemplateDoesNotExist
+from django.template.defaultfilters import floatformat
+from django.template.loader import render_to_string
+from django.urls import NoReverseMatch, reverse
+from django.utils.safestring import SafeText, mark_safe
+
+from common.utils import truncate
+from games.models import Game, Purchase, Session
+
+HTMLAttribute = tuple[str, str | int | bool]
+HTMLTag = str
+
+
+def Component(
+    attributes: list[HTMLAttribute] = [],
+    children: list[HTMLTag] | HTMLTag = [],
+    template: str = "",
+    tag_name: str = "",
+) -> HTMLTag:
+    if not tag_name and not template:
+        raise ValueError("One of template or tag_name is required.")
+    if isinstance(children, str):
+        children = [children]
+    childrenBlob = "\n".join(children)
+    if len(attributes) == 0:
+        attributesBlob = ""
+    else:
+        attributesList = [f'{name}="{value}"' for name, value in attributes]
+        # make attribute list into a string
+        # and insert space between tag and attribute list
+        attributesBlob = f" {' '.join(attributesList)}"
+    tag: str = ""
+    if tag_name != "":
+        tag = f"<{tag_name}{attributesBlob}>{childrenBlob}</{tag_name}>"
+    elif template != "":
+        tag = render_to_string(
+            template,
+            {name: value for name, value in attributes}
+            | {"slot": mark_safe("\n".join(children))},
+        )
+    return mark_safe(tag)
+
+
+def randomid(seed: str = "", length: int = 10) -> str:
+    return seed + "".join(random_choices(ascii_lowercase, k=length))
+
+
+def Popover(
+    popover_content: str,
+    wrapped_content: str = "",
+    wrapped_classes: str = "",
+    children: list[HTMLTag] = [],
+    attributes: list[HTMLAttribute] = [],
+) -> str:
+    if not wrapped_content and not children:
+        raise ValueError("One of wrapped_content or children is required.")
+    id = randomid()
+    return Component(
+        attributes=attributes
+        + [
+            ("id", id),
+            ("wrapped_content", wrapped_content),
+            ("popover_content", popover_content),
+            ("wrapped_classes", wrapped_classes),
+        ],
+        children=children,
+        template="cotton/popover.html",
+    )
+
+
+def PopoverTruncated(
+    input_string: str,
+    popover_content: str = "",
+    popover_if_not_truncated: bool = False,
+    length: int = 30,
+    ellipsis: str = "…",
+    endpart: str = "",
+) -> str:
+    """
+    Returns `input_string` truncated after `length` of characters
+    and displays the untruncated text in a popover HTML element.
+    The truncated text ends in `ellipsis`, and optionally
+    an always-visible `endpart` can be specified.
+    `popover_content` can be specified if:
+    1. It needs to be always displayed regardless if text is truncated.
+    2. It needs to differ from `input_string`.
+    """
+    if (truncated := truncate(input_string, length, ellipsis, endpart)) != input_string:
+        return Popover(
+            wrapped_content=truncated,
+            popover_content=popover_content if popover_content else input_string,
+        )
+    else:
+        if popover_content and popover_if_not_truncated:
+            return Popover(
+                wrapped_content=input_string,
+                popover_content=popover_content if popover_content else "",
+            )
+        else:
+            return input_string
+
+
+def A(
+    attributes: list[HTMLAttribute] = [],
+    children: list[HTMLTag] | HTMLTag = [],
+    url: str | Callable[..., Any] = "",
+):
+    """
+    Returns the HTML tag "a".
+    "url" can either be:
+        - URL (string)
+        - path name passed to reverse() (string)
+        - function
+    """
+    additional_attributes = []
+    if url:
+        if type(url) is str:
+            try:
+                url_result = reverse(url)
+            except NoReverseMatch:
+                url_result = url
+        elif callable(url):
+            url_result = url()
+        else:
+            raise TypeError("'url' is neither str nor function.")
+        additional_attributes = [("href", url_result)]
+    return Component(
+        tag_name="a", attributes=attributes + additional_attributes, children=children
+    )
+
+
+def Button(
+    attributes: list[HTMLAttribute] = [],
+    children: list[HTMLTag] | HTMLTag = [],
+    size: str = "base",
+    icon: bool = False,
+    color: str = "blue",
+):
+    return Component(
+        template="cotton/button.html",
+        attributes=attributes + [("size", size), ("icon", icon), ("color", color)],
+        children=children,
+    )
+
+
+def Div(
+    attributes: list[HTMLAttribute] = [],
+    children: list[HTMLTag] | HTMLTag = [],
+):
+    return Component(tag_name="div", attributes=attributes, children=children)
+
+
+def Input(
+    type: str = "text",
+    attributes: list[HTMLAttribute] = [],
+    children: list[HTMLTag] | HTMLTag = [],
+):
+    return Component(
+        tag_name="input", attributes=attributes + [("type", type)], children=children
+    )
+
+
+def Form(
+    action="",
+    method="get",
+    attributes: list[HTMLAttribute] = [],
+    children: list[HTMLTag] | HTMLTag = [],
+):
+    return Component(
+        tag_name="form",
+        attributes=attributes + [("action", action), ("method", method)],
+        children=children,
+    )
+
+
+def Icon(
+    name: str,
+    attributes: list[HTMLAttribute] = [],
+):
+    try:
+        result = Component(template=f"cotton/icon/{name}.html", attributes=attributes)
+    except TemplateDoesNotExist:
+        result = Icon(name="unspecified", attributes=attributes)
+    return result
+
+
+def LinkedPurchase(purchase: Purchase) -> SafeText:
+    link = reverse("view_purchase", args=[int(purchase.id)])
+    link_content = ""
+    popover_content = ""
+    game_count = purchase.games.count()
+    popover_if_not_truncated = False
+    if game_count == 1:
+        link_content += purchase.games.first().name
+        popover_content = link_content
+    if game_count > 1:
+        if purchase.name:
+            link_content += f"{purchase.name}"
+            popover_content += f"<h1>{purchase.name}</h1><br>"
+        else:
+            link_content += f"{game_count} games"
+            popover_if_not_truncated = True
+        popover_content += f"""
+        <ul class="list-disc list-inside">
+            {"".join(f"<li>{game.name}</li>" for game in purchase.games.all())}
+        </ul>
+        """
+    icon = purchase.platform.icon if game_count == 1 else "unspecified"
+    if link_content == "":
+        raise ValueError("link_content is empty!!")
+    a_content = Div(
+        [("class", "inline-flex gap-2 items-center")],
+        [
+            Icon(
+                icon,
+                [("title", "Multiple")],
+            ),
+            PopoverTruncated(
+                input_string=link_content,
+                popover_content=mark_safe(popover_content),
+                popover_if_not_truncated=popover_if_not_truncated,
+            ),
+        ],
+    )
+    return mark_safe(A(url=link, children=[a_content]))
+
+
+def NameWithIcon(
+    name: str = "",
+    platform: str = "",
+    game_id: int = 0,
+    session_id: int = 0,
+    purchase_id: int = 0,
+    linkify: bool = True,
+    emulated: bool = False,
+) -> SafeText:
+    create_link = False
+    link = ""
+    platform = None
+    if (game_id != 0 or session_id != 0 or purchase_id != 0) and linkify:
+        create_link = True
+        if session_id:
+            session = Session.objects.get(pk=session_id)
+            emulated = session.emulated
+            game_id = session.game.pk
+        if purchase_id:
+            purchase = Purchase.objects.get(pk=purchase_id)
+            game_id = purchase.games.first().pk
+        if game_id:
+            game = Game.objects.get(pk=game_id)
+        name = name or game.name
+        platform = game.platform
+        link = reverse("view_game", args=[int(game_id)])
+    content = Div(
+        [("class", "inline-flex gap-2 items-center")],
+        [
+            Icon(
+                platform.icon,
+                [("title", platform.name)],
+            )
+            if platform
+            else "",
+            Icon("emulated", [("title", "Emulated")]) if emulated else "",
+            PopoverTruncated(name),
+        ],
+    )
+
+    return mark_safe(
+        A(
+            url=link,
+            children=[content],
+        )
+        if create_link
+        else content,
+    )
+
+
+def PurchasePrice(purchase) -> str:
+    return Popover(
+        popover_content=f"{floatformat(purchase.price)} {purchase.price_currency}",
+        wrapped_content=f"{floatformat(purchase.converted_price)} {purchase.converted_currency}",
+        wrapped_classes="underline decoration-dotted",
+    )

common/input.css

@@ -2,21 +2,194 @@
 @tailwind components;
 @tailwind utilities;
 
-form label {
-  @apply dark:text-slate-400;
+@font-face {
+  font-family: "IBM Plex Mono";
+  src: url("fonts/IBMPlexMono-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
 }
 
-form input,
+@font-face {
+  font-family: "IBM Plex Sans";
+  src: url("fonts/IBMPlexSans-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "IBM Plex Serif";
+  src: url("fonts/IBMPlexSerif-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "IBM Plex Serif";
+  src: url("fonts/IBMPlexSerif-Bold.woff2") format("woff2");
+  font-weight: 700;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "IBM Plex Sans Condensed";
+  src: url("fonts/IBMPlexSansCondensed-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+}
+
+
+/* a:hover {
+  text-decoration-color: #ff4400;
+  color: rgb(254, 185, 160);
+  transition: all 0.2s ease-out;
+} */
+
+/* form label {
+  @apply dark:text-slate-400;
+} */
+
+.responsive-table {
+  @apply dark:text-white mx-auto table-fixed;
+}
+
+.responsive-table tr:nth-child(even) {
+  @apply bg-slate-800
+}
+
+.responsive-table tbody tr:nth-child(odd) {
+  @apply bg-slate-900
+}
+
+.responsive-table thead th {
+  @apply text-left border-b-2 border-b-slate-500 text-xl;
+}
+
+.responsive-table thead th:not(:first-child),
+.responsive-table td:not(:first-child) {
+  @apply border-l border-l-slate-500;
+}
+
+@layer utilities {
+  .min-w-20char {
+    min-width: 20ch;
+  }
+  .max-w-20char {
+    max-width: 20ch;
+  }
+  .min-w-30char {
+    min-width: 30ch;
+  }
+  .max-w-30char {
+    max-width: 30ch;
+  }
+  .max-w-35char {
+    max-width: 35ch;
+  }
+  .max-w-40char {
+    max-width: 40ch;
+  }
+}
+
+/* form input,
 select,
 textarea {
   @apply dark:border dark:border-slate-900 dark:bg-slate-500 dark:text-slate-100;
+} */
+
+form input:disabled,
+select:disabled,
+textarea:disabled {
+  @apply dark:bg-slate-800 dark:text-slate-500 cursor-not-allowed;
 }
 
-#session-table {
-  display: grid;
-  grid-template-columns: 3fr 1fr repeat(2, 2fr) 0.5fr 1fr;
+.errorlist {
+  @apply mt-4 mb-1 pl-3 py-2 bg-red-600 text-slate-200 w-[300px];
 }
 
+/* @media screen and (min-width: 768px) {
+  form input,
+  select,
+  textarea {
+    width: 300px;
+  }
+} */
+
+/* @media screen and (max-width: 768px) {
+  form input,
+  select,
+  textarea {
+    width: 150px;
+  }
+} */
+
 #button-container button {
   @apply mx-1;
 }
+
+.basic-button-container {
+  @apply flex space-x-2 justify-center;
+}
+
+.basic-button {
+  @apply inline-block px-6 py-2.5 bg-blue-600 text-white font-medium text-xs leading-tight uppercase rounded shadow-md hover:bg-blue-700 hover:shadow-lg focus:bg-blue-700 focus:shadow-lg focus:outline-none focus:ring-0 active:bg-blue-800 active:shadow-lg transition duration-150 ease-in-out;
+}
+
+.markdown-content ul {
+  list-style-type: disc;
+  list-style-position: inside;
+  padding-left: 1em;
+}
+
+.markdown-content ol {
+  list-style-type: decimal;
+  list-style-position: inside;
+  padding-left: 1em;
+}
+
+.markdown-content ul, 
+.markdown-content ol {
+    list-style-position: outside;
+    padding-left: 1em;
+}
+
+.markdown-content ul ul, 
+.markdown-content ul ol, 
+.markdown-content ol ul, 
+.markdown-content ol ol {
+    list-style-type: circle;
+    margin-top: 0.5em;
+    margin-bottom: 0.5em;
+    padding-left: 1em;
+}
+
+/* .truncate-container {
+  @apply inline-block relative;
+  a {
+    @apply inline-block truncate max-w-20char transition-all group-hover:absolute group-hover:max-w-none group-hover:-top-8 group-hover:-left-6 group-hover:min-w-60 group-hover:px-6 group-hover:py-3.5 group-hover:bg-purple-600 group-hover:rounded-sm group-hover:outline-dashed group-hover:outline-purple-400 group-hover:outline-4;
+    
+  }  
+} */
+
+label {
+  @apply dark:text-slate-500;
+}
+
+[type="text"], [type="password"], [type="datetime-local"], [type="datetime"], [type="date"], [type="number"], select, textarea {
+  @apply dark:bg-slate-600 dark:text-slate-300;
+}
+
+[type="submit"] {
+  @apply dark:text-white font-bold dark:bg-blue-600 px-4 py-2;
+}
+
+form div label {
+  @apply dark:text-white;
+}
+
+form div {
+  @apply flex flex-col;
+}
+
+div [type="submit"] {
+  @apply mt-3;
+}

common/plots.py

@@ -1,95 +0,0 @@
-import base64
-from datetime import datetime
-from io import BytesIO
-
-import matplotlib.pyplot as plt
-import matplotlib.dates as mdates
-import pandas as pd
-from django.db.models import F, IntegerField, QuerySet, Sum
-from django.db.models.functions import TruncDay
-from games.models import Session
-
-
-def key_value_to_value_value(data):
-    return {data["date"]: data["hours"]}
-
-
-def playtime_over_time_chart(queryset: QuerySet = Session.objects):
-    microsecond_in_second = 1000000
-    result = (
-        queryset.exclude(timestamp_end__exact=None)
-        .annotate(date=TruncDay("timestamp_start"))
-        .values("date")
-        .annotate(
-            hours=Sum(
-                F("duration_calculated"),
-                output_field=IntegerField(),
-            )
-        )
-        .values("date", "hours")
-    )
-    keys = []
-    values = []
-    running_total = int(0)
-    for item in result:
-        # date_value = datetime.strftime(item["date"], "%d-%m-%Y")
-        date_value = item["date"]
-        keys.append(date_value)
-        running_total += int(item["hours"] / (3600 * microsecond_in_second))
-        values.append(running_total)
-    data = [keys, values]
-    return get_chart(
-        data,
-        title="Playtime over time (manual excluded)",
-        xlabel="Date",
-        ylabel="Hours",
-    )
-
-
-def get_graph():
-    buffer = BytesIO()
-    plt.savefig(buffer, format="svg", transparent=True)
-    buffer.seek(0)
-    image_png = buffer.getvalue()
-    graph = base64.b64encode(image_png)
-    graph = graph.decode("utf-8")
-    buffer.close()
-    return graph
-
-
-def get_chart(data, title="", xlabel="", ylabel=""):
-    x = data[0]
-    y = data[1]
-    plt.style.use("dark_background")
-    plt.switch_backend("SVG")
-    fig, ax = plt.subplots()
-    fig.set_size_inches(10, 4)
-    lines = ax.plot(x, y, "-o")
-    first = x[0]
-    last = x[-1]
-    difference = last - first
-    if difference.days <= 14:
-        ax.xaxis.set_major_locator(mdates.DayLocator())
-    elif difference.days < 60 or len(x) < 60:
-        ax.xaxis.set_major_locator(mdates.WeekdayLocator())
-        ax.xaxis.set_minor_locator(mdates.DayLocator())
-    elif difference.days < 720:
-        ax.xaxis.set_major_locator(mdates.MonthLocator())
-        ax.xaxis.set_minor_locator(mdates.WeekdayLocator())
-        for line in lines:
-            line.set_marker("")
-    else:
-        for line in lines:
-            line.set_marker("")
-        ax.xaxis.set_major_locator(mdates.YearLocator())
-        ax.xaxis.set_minor_locator(mdates.MonthLocator())
-
-    ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y-%m-%d"))
-    for label in ax.get_xticklabels(which="major"):
-        label.set(rotation=30, horizontalalignment="right")
-    ax.set_xlabel(xlabel)
-    ax.set_ylabel(ylabel)
-    ax.set_title(title)
-    fig.tight_layout()
-    chart = get_graph()
-    return chart

common/time.py

@@ -1,16 +1,19 @@
 import re
-from datetime import datetime, timedelta
-from zoneinfo import ZoneInfo
+from datetime import date, datetime, timedelta
 
-from django.conf import settings
+from django.utils import timezone
 
+from common.utils import generate_split_ranges
 
-def now() -> datetime:
-    return datetime.now(ZoneInfo(settings.TIME_ZONE))
+dateformat: str = "%d/%m/%Y"
+datetimeformat: str = "%d/%m/%Y %H:%M"
+timeformat: str = "%H:%M"
+durationformat: str = "%2.1H hours"
+durationformat_manual: str = "%H hours"
 
 
 def _safe_timedelta(duration: timedelta | int | None):
-    if duration == None:
+    if duration is None:
         return timedelta(0)
     elif isinstance(duration, int):
         return timedelta(seconds=duration)
@@ -19,7 +22,7 @@ def _safe_timedelta(duration: timedelta | int | None):
 
 
 def format_duration(
-    duration: timedelta | int | None, format_string: str = "%H hours"
+    duration: timedelta | int | float | None, format_string: str = "%H hours"
 ) -> str:
     """
     Format timedelta into the specified format_string.
@@ -32,32 +35,135 @@ def format_duration(
     from the formatting string. For example:
     - 61 seconds as "%s" = 61 seconds
     - 61 seconds as "%m %s" = 1 minutes 1 seconds"
+    Format specifiers can include width and precision options:
+    - %5.2H: hours formatted with width 5 and 2 decimal places (padded with zeros)
     """
     minute_seconds = 60
     hour_seconds = 60 * minute_seconds
     day_seconds = 24 * hour_seconds
-    duration = _safe_timedelta(duration)
+    safe_duration = _safe_timedelta(duration)
     # we don't need float
-    seconds_total = int(duration.total_seconds())
+    seconds_total = int(safe_duration.total_seconds())
     # timestamps where end is before start
     if seconds_total < 0:
         seconds_total = 0
-    days = hours = minutes = seconds = 0
+    days = hours = hours_float = minutes = seconds = 0
     remainder = seconds = seconds_total
     if "%d" in format_string:
         days, remainder = divmod(seconds_total, day_seconds)
-    if "%H" in format_string:
-        hours, remainder = divmod(remainder, hour_seconds)
-    if "%m" in format_string:
+    if re.search(r"%\d*\.?\d*H", format_string):
+        hours_float, remainder = divmod(remainder, hour_seconds)
+        hours = float(hours_float) + remainder / hour_seconds
+    if re.search(r"%\d*\.?\d*m", format_string):
         minutes, seconds = divmod(remainder, minute_seconds)
     literals = {
-        "%d": str(days),
-        "%H": str(hours),
-        "%m": str(minutes),
-        "%s": str(seconds),
-        "%r": str(seconds_total),
+        "d": str(days),
+        "H": str(hours) if "m" not in format_string else str(hours_float),
+        "m": str(minutes),
+        "s": str(seconds),
+        "r": str(seconds_total),
     }
     formatted_string = format_string
     for pattern, replacement in literals.items():
-        formatted_string = re.sub(pattern, replacement, formatted_string)
+        # Match format specifiers with optional width and precision
+        match = re.search(rf"%(\d*\.?\d*){pattern}", formatted_string)
+        if match:
+            format_spec = match.group(1)
+            if "." in format_spec:
+                # Format the number as float if precision is specified
+                replacement = f"{float(replacement):{format_spec}f}"
+            else:
+                # Format the number as integer if no precision is specified
+                replacement = f"{int(float(replacement)):>{format_spec}}"
+            # Replace the format specifier with the formatted number
+            formatted_string = re.sub(
+                rf"%\d*\.?\d*{pattern}", replacement, formatted_string
+            )
     return formatted_string
+
+
+def local_strftime(datetime: datetime, format: str = datetimeformat) -> str:
+    return timezone.localtime(datetime).strftime(format)
+
+
+def daterange(start: date, end: date, end_inclusive: bool = False) -> list[date]:
+    time_between: timedelta = end - start
+    if (days_between := time_between.days) < 1:
+        raise ValueError("start and end have to be at least 1 day apart.")
+    if end_inclusive:
+        print(f"{end_inclusive=}")
+        print(f"{days_between=}")
+        days_between += 1
+    print(f"{days_between=}")
+    return [start + timedelta(x) for x in range(days_between)]
+
+
+def streak(datelist: list[date]) -> dict[str, int | tuple[date, date]]:
+    if len(datelist) == 1:
+        return {"days": 1, "dates": (datelist[0], datelist[0])}
+    else:
+        print(f"Processing {len(datelist)} dates.")
+        missing = sorted(
+            set(
+                datelist[0] + timedelta(x)
+                for x in range((datelist[-1] - datelist[0]).days)
+            )
+            - set(datelist)
+        )
+        print(f"{len(missing)} days missing.")
+        datelist_with_missing = sorted(datelist + missing)
+        ranges = list(generate_split_ranges(datelist_with_missing, missing))
+        print(f"{len(ranges)} ranges calculated.")
+        longest_consecutive_days = timedelta(0)
+        longest_range: tuple[date, date] = (date(1970, 1, 1), date(1970, 1, 1))
+        for start, end in ranges:
+            if (current_streak := end - start) > longest_consecutive_days:
+                longest_consecutive_days = current_streak
+                longest_range = (start, end)
+        return {"days": longest_consecutive_days.days + 1, "dates": longest_range}
+
+
+def streak_bruteforce(datelist: list[date]) -> dict[str, int | tuple[date, date]]:
+    if (datelist_length := len(datelist)) == 0:
+        raise ValueError("Number of dates in the list is 0.")
+    datelist.sort()
+    current_streak = 1
+    current_start = datelist[0]
+    current_end = datelist[0]
+    current_date = datelist[0]
+    highest_streak = 1
+    highest_streak_daterange = (current_start, current_end)
+
+    def update_highest_streak():
+        nonlocal highest_streak, highest_streak_daterange
+        if current_streak > highest_streak:
+            highest_streak = current_streak
+            highest_streak_daterange = (current_start, current_end)
+
+    def reset_streak():
+        nonlocal current_start, current_end, current_streak
+        current_start = current_end = current_date
+        current_streak = 1
+
+    def increment_streak():
+        nonlocal current_end, current_streak
+        current_end = current_date
+        current_streak += 1
+
+    for i, datelist_item in enumerate(datelist, start=1):
+        current_date = datelist_item
+        if current_date == current_start or current_date == current_end:
+            continue
+        if current_date - timedelta(1) != current_end and i != datelist_length:
+            update_highest_streak()
+            reset_streak()
+        elif current_date - timedelta(1) == current_end and i == datelist_length:
+            increment_streak()
+            update_highest_streak()
+        else:
+            increment_streak()
+    return {"days": highest_streak, "dates": highest_streak_daterange}
+
+
+def available_stats_year_range():
+    return range(datetime.now().year, 1999, -1)

common/utils.py

@@ -0,0 +1,167 @@
+import operator
+from dataclasses import dataclass
+from datetime import date
+from functools import reduce, wraps
+from typing import Any, Callable, Generator, Literal, TypeVar
+from urllib.parse import urlencode
+
+from django.db.models import Q
+from django.http import HttpRequest
+from django.shortcuts import redirect
+
+
+def safe_division(numerator: int | float, denominator: int | float) -> int | float:
+    """
+    Divides without triggering division by zero exception.
+    Returns 0 if denominator is 0.
+    """
+    try:
+        return numerator / denominator
+    except ZeroDivisionError:
+        return 0
+
+
+def safe_getattr(obj: object, attr_chain: str, default: Any | None = None) -> object:
+    """
+    Safely get the nested attribute from an object.
+
+    Parameters:
+    obj (object): The object from which to retrieve the attribute.
+    attr_chain (str): The chain of attributes, separated by dots.
+    default: The default value to return if any attribute in the chain does not exist.
+
+    Returns:
+    The value of the nested attribute if it exists, otherwise the default value.
+    """
+    attrs = attr_chain.split(".")
+    for attr in attrs:
+        try:
+            obj = getattr(obj, attr)
+        except AttributeError:
+            return default
+    return obj
+
+
+def truncate_(input_string: str, length: int = 30, ellipsis: str = "…") -> str:
+    return (
+        (f"{input_string[: length - len(ellipsis)].rstrip()}{ellipsis}")
+        if len(input_string) > length
+        else input_string
+    )
+
+
+def truncate(
+    input_string: str, length: int = 30, ellipsis: str = "…", endpart: str = ""
+) -> str:
+    max_content_length = length - len(endpart)
+    if max_content_length < 0:
+        raise ValueError("Length cannot be shorter than the length of endpart.")
+
+    if len(input_string) > max_content_length:
+        return f"{input_string[: max_content_length - len(ellipsis)].rstrip()}{ellipsis}{endpart}"
+
+    return (
+        f"{input_string}{endpart}"
+        if len(input_string) + len(endpart) <= length
+        else f"{input_string[: length - len(ellipsis) - len(endpart)].rstrip()}{ellipsis}{endpart}"
+    )
+
+
+T = TypeVar("T", str, int, date)
+
+
+def generate_split_ranges(
+    value_list: list[T], split_points: list[T]
+) -> Generator[tuple[T, T], None, None]:
+    for x in range(0, len(split_points) + 1):
+        if x == 0:
+            start = 0
+        elif x >= len(split_points):
+            start = value_list.index(split_points[x - 1]) + 1
+        else:
+            start = value_list.index(split_points[x - 1]) + 1
+        try:
+            end = value_list.index(split_points[x])
+        except IndexError:
+            end = len(value_list)
+        yield (value_list[start], value_list[end - 1])
+
+
+def format_float_or_int(number: int | float):
+    return int(number) if float(number).is_integer() else f"{number:03.2f}"
+
+
+OperatorType = Literal["|", "&"]
+
+
+@dataclass
+class FilterEntry:
+    condition: Q
+    operator: OperatorType = "&"
+
+
+def build_dynamic_filter(
+    filters: list[FilterEntry | Q], default_operator: OperatorType = "&"
+):
+    """
+    Constructs a Django Q filter from a list of filter conditions.
+
+    Args:
+        filters (list): A list where each item is either:
+            - A Q object (default AND logic applied)
+            - A tuple of (Q object, operator) where operator is "|" (OR) or "&" (AND)
+
+    Returns:
+        Q: A combined Q object that can be passed to Django's filter().
+    """
+    op_map: dict[OperatorType, Callable[[Q, Q], Q]] = {
+        "|": operator.or_,
+        "&": operator.and_,
+    }
+
+    # Convert all plain Q objects into (Q, "&") for default AND behavior
+    processed_filters = [
+        FilterEntry(f, default_operator) if isinstance(f, Q) else f for f in filters
+    ]
+
+    # Reduce with dynamic operators
+    return reduce(
+        lambda combined_filters, filter: op_map[filter.operator](
+            combined_filters, filter.condition
+        ),
+        processed_filters,
+        Q(),
+    )
+
+
+def redirect_to(default_view: str, *default_args):
+    """
+    A decorator that redirects the user back to the referring page or a default view if no 'next' parameter is provided.
+
+    :param default_view: The name of the default view to redirect to if 'next' is missing.
+    :param default_args: Any arguments required for the default view.
+    """
+
+    def decorator(view_func):
+        @wraps(view_func)
+        def wrapped_view(request: HttpRequest, *args, **kwargs):
+            next_url = request.GET.get("next")
+            if not next_url:
+                from django.urls import (
+                    reverse,  # Import inside function to avoid circular imports
+                )
+
+                next_url = reverse(default_view, args=default_args)
+
+            response = view_func(
+                request, *args, **kwargs
+            )  # Execute the original view logic
+            return redirect(next_url)
+
+        return wrapped_view
+
+    return decorator
+
+
+def add_next_param_to_url(url: str, nexturl: str) -> str:
+    return f"{url}?{urlencode({'next': nexturl})}"

contrib/scripts/get_exchange_rates_since_1990.py

@@ -0,0 +1,33 @@
+from datetime import datetime
+
+import requests
+
+url = "https://data.kurzy.cz/json/meny/b[6]den[{0}].json"
+date_format = "%Y%m%d"
+years = range(2000, datetime.now().year + 1)
+dates = [
+    datetime.strftime(datetime(day=1, month=1, year=year), format=date_format)
+    for year in years
+]
+for date in dates:
+    final_url = url.format(date)
+    year = date[:4]
+    response = requests.get(final_url)
+    response.raise_for_status()
+    data = response.json()
+    if kurzy := data.get("kurzy"):
+        with open("output.yaml", mode="a") as o:
+            rates = [
+                f"""
+- model: games.exchangerate
+            fields:
+            currency_from: {currency_name}
+            currency_to: CZK
+            year: {year}
+            rate: {kurzy.get(currency_name, {}).get("dev_stred", 0)}
+                """
+                for currency_name in ["EUR", "USD", "CNY"]
+                if kurzy.get(currency_name)
+            ]
+            o.writelines(rates)
+    # time.sleep(0.5)

contrib/scripts/merge_exchange_records.py

@@ -0,0 +1,65 @@
+import sys
+
+import yaml
+
+
+def load_yaml(filename):
+    with open(filename, "r", encoding="utf-8") as file:
+        return yaml.safe_load(file) or []
+
+
+def save_yaml(filename, data):
+    with open(filename, "w", encoding="utf-8") as file:
+        yaml.safe_dump(data, file, allow_unicode=True, default_flow_style=False)
+
+
+def extract_existing_combinations(data):
+    return {
+        (
+            entry["fields"]["currency_from"],
+            entry["fields"]["currency_to"],
+            entry["fields"]["year"],
+        )
+        for entry in data
+        if entry["model"] == "games.exchangerate"
+    }
+
+
+def filter_new_entries(existing_combinations, additional_files):
+    new_entries = []
+
+    for filename in additional_files:
+        data = load_yaml(filename)
+        for entry in data:
+            if entry["model"] == "games.exchangerate":
+                key = (
+                    entry["fields"]["currency_from"],
+                    entry["fields"]["currency_to"],
+                    entry["fields"]["year"],
+                )
+                if key not in existing_combinations:
+                    new_entries.append(entry)
+
+    return new_entries
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: script.py example.yaml additions1.yaml [additions2.yaml ...]")
+        sys.exit(1)
+
+    example_file = sys.argv[1]
+    additional_files = sys.argv[2:]
+    output_file = "filtered_output.yaml"
+
+    existing_data = load_yaml(example_file)
+    existing_combinations = extract_existing_combinations(existing_data)
+
+    new_entries = filter_new_entries(existing_combinations, additional_files)
+
+    save_yaml(output_file, new_entries)
+    print(f"Filtered data saved to {output_file}")
+
+
+if __name__ == "__main__":
+    main()

devcontainer.Dockerfile

@@ -0,0 +1,24 @@
+FROM python:3.13-slim
+
+# Set up environment
+ENV PYTHONUNBUFFERED=1
+WORKDIR /workspace
+
+# Install Poetry
+RUN apt-get update && apt-get install -y \
+        curl \
+        make \
+        npm \
+    && rm -rf /var/lib/apt/lists/*
+RUN curl -sSL https://install.python-poetry.org | python3 -
+ENV PATH="/root/.local/bin:$PATH"
+
+# Copy pyproject.toml and poetry.lock for dependency installation
+COPY pyproject.toml poetry.lock* ./
+RUN poetry install --no-root
+
+# Copy the rest of the application code
+COPY . .
+
+# Set up Django development server
+EXPOSE 8000

docker-compose.yml

@@ -10,13 +10,14 @@ services:
       - CSRF_TRUSTED_ORIGINS="https://tracker.kucharczyk.xyz"
     user: "1000"
     volumes:
-      - "static-files:/home/timetracker/app/static"
+      - "static-files:/var/www/django/static"
+      - "$PWD/db.sqlite3:/home/timetracker/app/db.sqlite3"
     restart: unless-stopped
 
   frontend:
     image: caddy
     volumes:
-      - "static-files:/usr/share/caddy"
+      - "static-files:/usr/share/caddy:ro"
       - "$PWD/Caddyfile:/etc/caddy/Caddyfile"
     ports:
       - "8000:8000"
@@ -26,3 +27,4 @@ services:
 volumes:
   static-files:
     
+    

entrypoint.sh

@@ -7,5 +7,17 @@ poetry run python manage.py migrate
 echo "Collect static files"
 poetry run python manage.py collectstatic --clear --no-input
 
+_term() {
+  echo "Caught SIGTERM signal!"
+  kill -SIGTERM "$gunicorn_pid"
+  kill -SIGTERM "$django_q_pid"
+}
+trap _term SIGTERM
+
+echo "Starting Django-Q cluster"
+poetry run python manage.py qcluster & django_q_pid=$!
+
 echo "Starting app"
-poetry run python -m gunicorn --bind 0.0.0.0:8001 timetracker.asgi:application -k uvicorn.workers.UvicornWorker --access-logfile - --error-logfile -
+poetry run python -m gunicorn --bind 0.0.0.0:8001 timetracker.asgi:application -k uvicorn.workers.UvicornWorker --access-logfile - --error-logfile - & gunicorn_pid=$!
+
+wait "$gunicorn_pid" "$django_q_pid"

games/admin.py

@@ -1,9 +1,18 @@
 from django.contrib import admin
 
-from games.models import Game, Platform, Purchase, Session
+from games.models import (
+    Device,
+    ExchangeRate,
+    Game,
+    Platform,
+    Purchase,
+    Session,
+)
 
 # Register your models here.
 admin.site.register(Game)
 admin.site.register(Purchase)
 admin.site.register(Platform)
 admin.site.register(Session)
+admin.site.register(Device)
+admin.site.register(ExchangeRate)

games/api.py

@@ -0,0 +1,80 @@
+from datetime import date, datetime
+from typing import List
+
+from django.shortcuts import get_object_or_404
+from django.utils.timezone import now as django_timezone_now
+from ninja import Field, ModelSchema, NinjaAPI, Router, Schema
+
+from games.models import PlayEvent
+
+api = NinjaAPI()
+playevent_router = Router()
+
+NOW_FACTORY = django_timezone_now
+
+
+class PlayEventIn(Schema):
+    game_id: int
+    started: date | None = None
+    ended: date | None = None
+    note: str = ""
+    days_to_finish: int | None = None
+
+
+class AutoPlayEventIn(ModelSchema):
+    class Meta:
+        model = PlayEvent
+        fields = ["game", "started", "ended", "note"]
+
+
+class UpdatePlayEventIn(Schema):
+    started: date | None = None
+    ended: date | None = None
+    note: str = ""
+
+
+class PlayEventOut(Schema):
+    id: int
+    game: str = Field(..., alias="game.name")
+    started: date | None = None
+    ended: date | None = None
+    days_to_finish: int | None = None
+    note: str = ""
+    updated_at: datetime
+    created_at: datetime
+
+
+@playevent_router.get("/", response=List[PlayEventOut])
+def list_playevents(request):
+    return PlayEvent.objects.all()
+
+
+@playevent_router.post("/", response={201: PlayEventOut})
+def create_playevent(request, payload: PlayEventIn):
+    playevent = PlayEvent.objects.create(**payload.dict())
+    return playevent
+
+
+@playevent_router.get("/{playevent_id}", response=PlayEventOut)
+def get_playevent(request, playevent_id: int):
+    playevent = get_object_or_404(PlayEvent, id=playevent_id)
+    return playevent
+
+
+@playevent_router.patch("/{playevent_id}", response=PlayEventOut)
+def partial_update_playevent(request, playevent_id: int, payload: UpdatePlayEventIn):
+    playevent = get_object_or_404(PlayEvent, id=playevent_id)
+    for attr, value in payload.dict(exclude_unset=True).items():
+        setattr(playevent, attr, value)
+    playevent.save()
+    return playevent
+
+
+@playevent_router.delete("/{playevent_id}", response={204: None})
+def delete_playevent(request, playevent_id: int):
+    playevent = get_object_or_404(PlayEvent, id=playevent_id)
+    playevent.delete()
+    return 204, None
+
+
+api.add_router("/playevent", playevent_router)

games/apps.py

@@ -1,6 +1,46 @@
+# from datetime import timedelta
+
 from django.apps import AppConfig
+from django.core.management import call_command
+from django.db.models.signals import post_migrate
+
+# from django.utils.timezone import now
 
 
 class GamesConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "games"
+
+    def ready(self):
+        import games.signals  # noqa: F401
+
+        post_migrate.connect(schedule_tasks, sender=self)
+
+
+def schedule_tasks(sender, **kwargs):
+    # from django_q.models import Schedule
+    # from django_q.tasks import schedule
+
+    # if not Schedule.objects.filter(name="Update converted prices").exists():
+    #     schedule(
+    #         "games.tasks.convert_prices",
+    #         name="Update converted prices",
+    #         schedule_type=Schedule.MINUTES,
+    #         next_run=now() + timedelta(seconds=30),
+    #         catchup=False,
+    #     )
+
+    # if not Schedule.objects.filter(name="Update price per game").exists():
+    #     schedule(
+    #         "games.tasks.calculate_price_per_game",
+    #         name="Update price per game",
+    #         schedule_type=Schedule.MINUTES,
+    #         next_run=now() + timedelta(seconds=30),
+    #         catchup=False,
+    #     )
+
+    from games.models import ExchangeRate
+
+    if not ExchangeRate.objects.exists():
+        print("ExchangeRate table is empty. Loading fixture...")
+        call_command("loaddata", "exchangerates.yaml")

games/fixtures/exchangerates.yaml

@@ -0,0 +1,504 @@
+- model: games.exchangerate
+  pk: 1
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2024
+    rate: 23.4
+- model: games.exchangerate
+  pk: 2
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2024
+    rate: 3.267
+- model: games.exchangerate
+  pk: 3
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2019
+    rate: 22.466
+- model: games.exchangerate
+  pk: 4
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2023
+    rate: 22.63
+- model: games.exchangerate
+  pk: 5
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2017
+    rate: 25.819
+- model: games.exchangerate
+  pk: 6
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2013
+    rate: 19.023
+- model: games.exchangerate
+  pk: 7
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2019
+    rate: 3.295
+- model: games.exchangerate
+  pk: 8
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2016
+    rate: 3.795
+- model: games.exchangerate
+  pk: 9
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2015
+    rate: 3.707
+- model: games.exchangerate
+  pk: 10
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2020
+    rate: 3.26
+- model: games.exchangerate
+  pk: 11
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2012
+    rate: 25.51
+- model: games.exchangerate
+  pk: 12
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2010
+    rate: 26.465
+- model: games.exchangerate
+  pk: 13
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2014
+    rate: 27.52
+- model: games.exchangerate
+  pk: 14
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2024
+    rate: 25.21
+- model: games.exchangerate
+  pk: 15
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2022
+    rate: 24.325
+- model: games.exchangerate
+  pk: 16
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2018
+    rate: 3.268
+- model: games.exchangerate
+  pk: 17
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2023
+    rate: 3.281
+- model: games.exchangerate
+  pk: 18
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2009
+    rate: 26.445
+- model: games.exchangerate
+  pk: 19
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2025
+    rate: 3.35
+- model: games.exchangerate
+  pk: 20
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2016
+    rate: 27.033
+- model: games.exchangerate
+  pk: 21
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2025
+    rate: 25.2021966
+- model: games.exchangerate
+  pk: 22
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2017
+    rate: 26.33
+- model: games.exchangerate
+  pk: 23
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2000
+    rate: 36.13
+- model: games.exchangerate
+  pk: 24
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2000
+    rate: 35.979
+- model: games.exchangerate
+  pk: 25
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2001
+    rate: 35.09
+- model: games.exchangerate
+  pk: 26
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2001
+    rate: 37.813
+- model: games.exchangerate
+  pk: 27
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2002
+    rate: 31.98
+- model: games.exchangerate
+  pk: 28
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2002
+    rate: 36.259
+- model: games.exchangerate
+  pk: 29
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2003
+    rate: 31.6
+- model: games.exchangerate
+  pk: 30
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2003
+    rate: 30.141
+- model: games.exchangerate
+  pk: 31
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2004
+    rate: 32.405
+- model: games.exchangerate
+  pk: 32
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2004
+    rate: 25.654
+- model: games.exchangerate
+  pk: 33
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2005
+    rate: 30.465
+- model: games.exchangerate
+  pk: 34
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2005
+    rate: 22.365
+- model: games.exchangerate
+  pk: 35
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2006
+    rate: 29.005
+- model: games.exchangerate
+  pk: 36
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2006
+    rate: 24.588
+- model: games.exchangerate
+  pk: 37
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2006
+    rate: 3.047
+- model: games.exchangerate
+  pk: 38
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2007
+    rate: 27.495
+- model: games.exchangerate
+  pk: 39
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2007
+    rate: 20.876
+- model: games.exchangerate
+  pk: 40
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2007
+    rate: 2.674
+- model: games.exchangerate
+  pk: 41
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2008
+    rate: 26.62
+- model: games.exchangerate
+  pk: 42
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2008
+    rate: 18.078
+- model: games.exchangerate
+  pk: 43
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2008
+    rate: 2.475
+- model: games.exchangerate
+  pk: 44
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2009
+    rate: 19.346
+- model: games.exchangerate
+  pk: 45
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2009
+    rate: 2.836
+- model: games.exchangerate
+  pk: 46
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2010
+    rate: 18.368
+- model: games.exchangerate
+  pk: 47
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2010
+    rate: 2.691
+- model: games.exchangerate
+  pk: 48
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2011
+    rate: 25.06
+- model: games.exchangerate
+  pk: 49
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2011
+    rate: 18.751
+- model: games.exchangerate
+  pk: 50
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2011
+    rate: 2.845
+- model: games.exchangerate
+  pk: 51
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2012
+    rate: 19.94
+- model: games.exchangerate
+  pk: 52
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2012
+    rate: 3.168
+- model: games.exchangerate
+  pk: 53
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2013
+    rate: 25.14
+- model: games.exchangerate
+  pk: 54
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2013
+    rate: 3.059
+- model: games.exchangerate
+  pk: 55
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2014
+    rate: 19.894
+- model: games.exchangerate
+  pk: 56
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2014
+    rate: 3.286
+- model: games.exchangerate
+  pk: 57
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2015
+    rate: 27.725
+- model: games.exchangerate
+  pk: 58
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2015
+    rate: 22.834
+- model: games.exchangerate
+  pk: 59
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2016
+    rate: 24.824
+- model: games.exchangerate
+  pk: 60
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2017
+    rate: 3.693
+- model: games.exchangerate
+  pk: 61
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2018
+    rate: 25.54
+- model: games.exchangerate
+  pk: 62
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2018
+    rate: 21.291
+- model: games.exchangerate
+  pk: 63
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2019
+    rate: 25.725
+- model: games.exchangerate
+  pk: 64
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2020
+    rate: 25.41
+- model: games.exchangerate
+  pk: 65
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2020
+    rate: 22.621
+- model: games.exchangerate
+  pk: 66
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2021
+    rate: 26.245
+- model: games.exchangerate
+  pk: 67
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2021
+    rate: 21.387
+- model: games.exchangerate
+  pk: 68
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2021
+    rate: 3.273
+- model: games.exchangerate
+  pk: 69
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2022
+    rate: 21.951
+- model: games.exchangerate
+  pk: 70
+  fields:
+    currency_from: CNY
+    currency_to: CZK
+    year: 2022
+    rate: 3.458
+- model: games.exchangerate
+  pk: 71
+  fields:
+    currency_from: EUR
+    currency_to: CZK
+    year: 2023
+    rate: 24.115
+- model: games.exchangerate
+  pk: 72
+  fields:
+    currency_from: USD
+    currency_to: CZK
+    year: 2025
+    rate: 24.237

games/forms.py

@@ -1,46 +1,267 @@
 from django import forms
+from django.db import transaction
+from django.urls import reverse
 
-from games.models import Game, Platform, Purchase, Session, Edition
+from common.utils import safe_getattr
+from games.models import (
+    Device,
+    Game,
+    GameStatusChange,
+    Platform,
+    PlayEvent,
+    Purchase,
+    Session,
+)
+
+custom_date_widget = forms.DateInput(attrs={"type": "date"})
+custom_datetime_widget = forms.DateTimeInput(
+    attrs={"type": "datetime-local"}, format="%Y-%m-%d %H:%M"
+)
+autofocus_input_widget = forms.TextInput(attrs={"autofocus": "autofocus"})
+
+
+class MultipleGameChoiceField(forms.ModelMultipleChoiceField):
+    def label_from_instance(self, obj) -> str:
+        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
+
+
+class SingleGameChoiceField(forms.ModelChoiceField):
+    def label_from_instance(self, obj) -> str:
+        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
 
 
 class SessionForm(forms.ModelForm):
-    purchase = forms.ModelChoiceField(
-        queryset=Purchase.objects.order_by("edition__name")
+    game = SingleGameChoiceField(
+        queryset=Game.objects.order_by("sort_name"),
+        widget=forms.Select(attrs={"autofocus": "autofocus"}),
+    )
+
+    duration_manual = forms.DurationField(
+        required=False,
+        widget=forms.TextInput(
+            attrs={"x-mask": "99:99:99", "placeholder": "HH:MM:SS", "x-data": ""}
+        ),
+        label="Manual duration",
+    )
+    device = forms.ModelChoiceField(queryset=Device.objects.order_by("name"))
+
+    mark_as_played = forms.BooleanField(
+        required=False,
+        initial={"mark_as_played": True},
+        label="Set game status to Played if Unplayed",
     )
 
     class Meta:
+        widgets = {
+            "timestamp_start": custom_datetime_widget,
+            "timestamp_end": custom_datetime_widget,
+        }
         model = Session
         fields = [
-            "purchase",
+            "game",
             "timestamp_start",
             "timestamp_end",
             "duration_manual",
+            "emulated",
+            "device",
             "note",
+            "mark_as_played",
         ]
 
+    def save(self, commit=True):
+        session = super().save(commit=False)
+        if self.cleaned_data.get("mark_as_played"):
+            game_instance = session.game
+            if game_instance.status == "u":
+                game_instance.status = "p"
+            if commit:
+                game_instance.save()
+        if commit:
+            session.save()
+        return session
+
+
+class IncludePlatformSelect(forms.SelectMultiple):
+    def create_option(self, name, value, *args, **kwargs):
+        option = super().create_option(name, value, *args, **kwargs)
+        if platform_id := safe_getattr(value, "instance.platform.id"):
+            option["attrs"]["data-platform"] = platform_id
+        return option
+
 
 class PurchaseForm(forms.ModelForm):
-    edition = forms.ModelChoiceField(queryset=Edition.objects.order_by("name"))
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # Automatically update related_purchase <select/>
+        # to only include purchases of the selected game.
+        related_purchase_by_game_url = reverse("related_purchase_by_game")
+        self.fields["games"].widget.attrs.update(
+            {
+                "hx-trigger": "load, click",
+                "hx-get": related_purchase_by_game_url,
+                "hx-target": "#id_related_purchase",
+                "hx-swap": "outerHTML",
+            }
+        )
+
+    games = MultipleGameChoiceField(
+        queryset=Game.objects.order_by("sort_name"),
+        widget=IncludePlatformSelect(attrs={"autoselect": "autoselect"}),
+    )
     platform = forms.ModelChoiceField(queryset=Platform.objects.order_by("name"))
+    related_purchase = forms.ModelChoiceField(
+        queryset=Purchase.objects.filter(type=Purchase.GAME),
+        required=False,
+    )
+
+    price_currency = forms.CharField(
+        widget=forms.TextInput(
+            attrs={
+                "x-mask": "aaa",
+                "placeholder": "CZK",
+                "x-data": "",
+                "class": "uppercase",
+            }
+        ),
+        label="Currency",
+    )
 
     class Meta:
+        widgets = {
+            "date_purchased": custom_date_widget,
+            "date_refunded": custom_date_widget,
+        }
         model = Purchase
-        fields = ["edition", "platform", "date_purchased", "date_refunded"]
+        fields = [
+            "games",
+            "platform",
+            "date_purchased",
+            "date_refunded",
+            "infinite",
+            "price",
+            "price_currency",
+            "ownership_type",
+            "type",
+            "related_purchase",
+            "name",
+        ]
+
+    def clean(self):
+        cleaned_data = super().clean()
+        purchase_type = cleaned_data.get("type")
+        related_purchase = cleaned_data.get("related_purchase")
+        name = cleaned_data.get("name")
+
+        # Set the type on the instance to use get_type_display()
+        # This is safe because we're not saving the instance.
+        self.instance.type = purchase_type
+
+        if purchase_type != Purchase.GAME:
+            type_display = self.instance.get_type_display()
+            if not related_purchase:
+                self.add_error(
+                    "related_purchase",
+                    f"{type_display} must have a related purchase.",
+                )
+            if not name:
+                self.add_error("name", f"{type_display} must have a name.")
+        return cleaned_data
 
 
-class EditionForm(forms.ModelForm):
-    class Meta:
-        model = Edition
-        fields = ["game", "name", "platform"]
+class IncludeNameSelect(forms.Select):
+    def create_option(self, name, value, *args, **kwargs):
+        option = super().create_option(name, value, *args, **kwargs)
+        if value:
+            option["attrs"]["data-name"] = value.instance.name
+            option["attrs"]["data-year"] = value.instance.year_released
+        return option
+
+
+class GameModelChoiceField(forms.ModelChoiceField):
+    def label_from_instance(self, obj):
+        # Use sort_name as the label for the option
+        return obj.sort_name
 
 
 class GameForm(forms.ModelForm):
+    platform = forms.ModelChoiceField(
+        queryset=Platform.objects.order_by("name"), required=False
+    )
+
     class Meta:
         model = Game
-        fields = ["name", "wikidata"]
+        fields = [
+            "name",
+            "sort_name",
+            "platform",
+            "original_year_released",
+            "year_released",
+            "status",
+            "mastered",
+            "wikidata",
+        ]
+        widgets = {"name": autofocus_input_widget}
 
 
 class PlatformForm(forms.ModelForm):
     class Meta:
         model = Platform
-        fields = ["name", "group"]
+        fields = [
+            "name",
+            "icon",
+            "group",
+        ]
+        widgets = {"name": autofocus_input_widget}
+
+
+class DeviceForm(forms.ModelForm):
+    class Meta:
+        model = Device
+        fields = ["name", "type"]
+        widgets = {"name": autofocus_input_widget}
+
+
+class PlayEventForm(forms.ModelForm):
+    game = GameModelChoiceField(
+        queryset=Game.objects.order_by("sort_name"),
+        widget=forms.Select(attrs={"autofocus": "autofocus"}),
+    )
+
+    mark_as_finished = forms.BooleanField(
+        required=False,
+        initial={"mark_as_finished": True},
+        label="Set game status to Finished",
+    )
+
+    class Meta:
+        model = PlayEvent
+        fields = ["game", "started", "ended", "note", "mark_as_finished"]
+        widgets = {
+            "started": custom_date_widget,
+            "ended": custom_date_widget,
+        }
+
+    def save(self, commit=True):
+        with transaction.atomic():
+            session = super().save(commit=False)
+            if self.cleaned_data.get("mark_as_finished"):
+                game_instance = session.game
+                game_instance.status = "f"
+                game_instance.save()
+            session.save()
+        return session
+
+
+class GameStatusChangeForm(forms.ModelForm):
+    class Meta:
+        model = GameStatusChange
+        fields = [
+            "game",
+            "old_status",
+            "new_status",
+            "timestamp",
+        ]
+        widgets = {
+            "timestamp": custom_datetime_widget,
+        }

games/graphql/mutations/__init__.py

@@ -0,0 +1 @@
+from .game import Mutation as GameMutation

games/graphql/mutations/game.py

@@ -0,0 +1,29 @@
+import graphene
+
+from games.graphql.types import Game
+from games.models import Game as GameModel
+
+
+class UpdateGameMutation(graphene.Mutation):
+    class Arguments:
+        id = graphene.ID(required=True)
+        name = graphene.String()
+        year_released = graphene.Int()
+        wikidata = graphene.String()
+
+    game = graphene.Field(Game)
+
+    def mutate(self, info, id, name=None, year_released=None, wikidata=None):
+        game_instance = GameModel.objects.get(pk=id)
+        if name is not None:
+            game_instance.name = name
+        if year_released is not None:
+            game_instance.year_released = year_released
+        if wikidata is not None:
+            game_instance.wikidata = wikidata
+        game_instance.save()
+        return UpdateGameMutation(game=game_instance)
+
+
+class Mutation(graphene.ObjectType):
+    update_game = UpdateGameMutation.Field()

games/graphql/queries/__init__.py

@@ -0,0 +1,5 @@
+from .device import Query as DeviceQuery
+from .game import Query as GameQuery
+from .platform import Query as PlatformQuery
+from .purchase import Query as PurchaseQuery
+from .session import Query as SessionQuery

games/graphql/queries/device.py

@@ -0,0 +1,11 @@
+import graphene
+
+from games.graphql.types import Device
+from games.models import Device as DeviceModel
+
+
+class Query(graphene.ObjectType):
+    devices = graphene.List(Device)
+
+    def resolve_devices(self, info, **kwargs):
+        return DeviceModel.objects.all()

games/graphql/queries/game.py

@@ -0,0 +1,18 @@
+import graphene
+
+from games.graphql.types import Game
+from games.models import Game as GameModel
+
+
+class Query(graphene.ObjectType):
+    games = graphene.List(Game)
+    game_by_name = graphene.Field(Game, name=graphene.String(required=True))
+
+    def resolve_games(self, info, **kwargs):
+        return GameModel.objects.all()
+
+    def resolve_game_by_name(self, info, name):
+        try:
+            return GameModel.objects.get(name=name)
+        except GameModel.DoesNotExist:
+            return None

games/graphql/queries/platform.py

@@ -0,0 +1,11 @@
+import graphene
+
+from games.graphql.types import Platform
+from games.models import Platform as PlatformModel
+
+
+class Query(graphene.ObjectType):
+    platforms = graphene.List(Platform)
+
+    def resolve_platforms(self, info, **kwargs):
+        return PlatformModel.objects.all()

games/graphql/queries/purchase.py

@@ -0,0 +1,11 @@
+import graphene
+
+from games.graphql.types import Purchase
+from games.models import Purchase as PurchaseModel
+
+
+class Query(graphene.ObjectType):
+    purchases = graphene.List(Purchase)
+
+    def resolve_purchases(self, info, **kwargs):
+        return PurchaseModel.objects.all()

games/graphql/queries/session.py

@@ -0,0 +1,11 @@
+import graphene
+
+from games.graphql.types import Session
+from games.models import Session as SessionModel
+
+
+class Query(graphene.ObjectType):
+    sessions = graphene.List(Session)
+
+    def resolve_sessions(self, info, **kwargs):
+        return SessionModel.objects.all()

games/graphql/types.py

@@ -0,0 +1,44 @@
+from graphene_django import DjangoObjectType
+
+from games.models import Device as DeviceModel
+from games.models import Edition as EditionModel
+from games.models import Game as GameModel
+from games.models import Platform as PlatformModel
+from games.models import Purchase as PurchaseModel
+from games.models import Session as SessionModel
+
+
+class Game(DjangoObjectType):
+    class Meta:
+        model = GameModel
+        fields = "__all__"
+
+
+class Edition(DjangoObjectType):
+    class Meta:
+        model = EditionModel
+        fields = "__all__"
+
+
+class Purchase(DjangoObjectType):
+    class Meta:
+        model = PurchaseModel
+        fields = "__all__"
+
+
+class Session(DjangoObjectType):
+    class Meta:
+        model = SessionModel
+        fields = "__all__"
+
+
+class Platform(DjangoObjectType):
+    class Meta:
+        model = PlatformModel
+        fields = "__all__"
+
+
+class Device(DjangoObjectType):
+    class Meta:
+        model = DeviceModel
+        fields = "__all__"

games/management/commands/schedule_convert_prices.py

@@ -0,0 +1,24 @@
+from datetime import timedelta
+
+from django.core.management.base import BaseCommand
+from django.utils.timezone import now
+from django_q.models import Schedule
+from django_q.tasks import schedule
+
+
+class Command(BaseCommand):
+    help = "Manually schedule the next update_converted_prices task"
+
+    def handle(self, *args, **kwargs):
+        if not Schedule.objects.filter(name="Update converted prices").exists():
+            schedule(
+                "games.tasks.convert_prices",
+                name="Update converted prices",
+                schedule_type=Schedule.MINUTES,
+                next_run=now() + timedelta(seconds=30),
+            )
+            self.stdout.write(
+                self.style.SUCCESS("Scheduled the update_converted_prices task.")
+            )
+        else:
+            self.stdout.write(self.style.WARNING("Task is already scheduled."))

games/migrations/0001_initial.py

@@ -1,5 +1,6 @@
-# Generated by Django 4.1.4 on 2023-01-02 18:27
+# Generated by Django 5.1.5 on 2025-01-29 21:26
 
+import datetime
 import django.db.models.deletion
 from django.db import migrations, models
 
@@ -8,94 +9,96 @@ class Migration(migrations.Migration):
 
     initial = True
 
-    dependencies = []
+    dependencies = [
+    ]
 
     operations = [
         migrations.CreateModel(
-            name="Game",
+            name='Device',
             fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("name", models.CharField(max_length=255)),
-                ("wikidata", models.CharField(max_length=50)),
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=255)),
+                ('type', models.CharField(choices=[('PC', 'PC'), ('Console', 'Console'), ('Handheld', 'Handheld'), ('Mobile', 'Mobile'), ('Single-board computer', 'Single-board computer'), ('Unknown', 'Unknown')], default='Unknown', max_length=255)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
             ],
         ),
         migrations.CreateModel(
-            name="Platform",
+            name='Platform',
             fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("name", models.CharField(max_length=255)),
-                ("group", models.CharField(max_length=255)),
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=255)),
+                ('group', models.CharField(blank=True, default=None, max_length=255, null=True)),
+                ('icon', models.SlugField(blank=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
             ],
         ),
         migrations.CreateModel(
-            name="Purchase",
+            name='ExchangeRate',
             fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("date_purchased", models.DateField()),
-                ("date_refunded", models.DateField(blank=True, null=True)),
-                (
-                    "game",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE, to="games.game"
-                    ),
-                ),
-                (
-                    "platform",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        to="games.platform",
-                    ),
-                ),
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('currency_from', models.CharField(max_length=255)),
+                ('currency_to', models.CharField(max_length=255)),
+                ('year', models.PositiveIntegerField()),
+                ('rate', models.FloatField()),
+            ],
+            options={
+                'unique_together': {('currency_from', 'currency_to', 'year')},
+            },
+        ),
+        migrations.CreateModel(
+            name='Game',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('name', models.CharField(max_length=255)),
+                ('sort_name', models.CharField(blank=True, default=None, max_length=255, null=True)),
+                ('year_released', models.IntegerField(blank=True, default=None, null=True)),
+                ('wikidata', models.CharField(blank=True, default=None, max_length=50, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('platform', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_DEFAULT, to='games.platform')),
+            ],
+            options={
+                'unique_together': {('name', 'platform', 'year_released')},
+            },
+        ),
+        migrations.CreateModel(
+            name='Purchase',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('date_purchased', models.DateField()),
+                ('date_refunded', models.DateField(blank=True, null=True)),
+                ('date_finished', models.DateField(blank=True, null=True)),
+                ('date_dropped', models.DateField(blank=True, null=True)),
+                ('infinite', models.BooleanField(default=False)),
+                ('price', models.FloatField(default=0)),
+                ('price_currency', models.CharField(default='USD', max_length=3)),
+                ('converted_price', models.FloatField(null=True)),
+                ('converted_currency', models.CharField(max_length=3, null=True)),
+                ('ownership_type', models.CharField(choices=[('ph', 'Physical'), ('di', 'Digital'), ('du', 'Digital Upgrade'), ('re', 'Rented'), ('bo', 'Borrowed'), ('tr', 'Trial'), ('de', 'Demo'), ('pi', 'Pirated')], default='di', max_length=2)),
+                ('type', models.CharField(choices=[('game', 'Game'), ('dlc', 'DLC'), ('season_pass', 'Season Pass'), ('battle_pass', 'Battle Pass')], default='game', max_length=255)),
+                ('name', models.CharField(blank=True, default='', max_length=255, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('games', models.ManyToManyField(blank=True, related_name='purchases', to='games.game')),
+                ('platform', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.CASCADE, to='games.platform')),
+                ('related_purchase', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='related_purchases', to='games.purchase')),
             ],
         ),
         migrations.CreateModel(
-            name="Session",
+            name='Session',
             fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("timestamp_start", models.DateTimeField()),
-                ("timestamp_end", models.DateTimeField()),
-                ("duration_manual", models.DurationField(blank=True, null=True)),
-                ("duration_calculated", models.DurationField(blank=True, null=True)),
-                ("note", models.TextField(blank=True, null=True)),
-                (
-                    "purchase",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE,
-                        to="games.purchase",
-                    ),
-                ),
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('timestamp_start', models.DateTimeField()),
+                ('timestamp_end', models.DateTimeField(blank=True, null=True)),
+                ('duration_manual', models.DurationField(blank=True, default=datetime.timedelta(0), null=True)),
+                ('duration_calculated', models.DurationField(blank=True, null=True)),
+                ('note', models.TextField(blank=True, null=True)),
+                ('emulated', models.BooleanField(default=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('modified_at', models.DateTimeField(auto_now=True)),
+                ('device', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_DEFAULT, to='games.device')),
+                ('game', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='sessions', to='games.game')),
             ],
+            options={
+                'get_latest_by': 'timestamp_start',
+            },
         ),
     ]

games/migrations/0002_alter_session_duration_manual.py

@@ -1,22 +0,0 @@
-# Generated by Django 4.1.4 on 2023-01-02 18:55
-
-import datetime
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0001_initial"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="session",
-            name="duration_manual",
-            field=models.DurationField(
-                blank=True, default=datetime.timedelta(0), null=True
-            ),
-        ),
-    ]

games/migrations/0002_purchase_price_per_game.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.5 on 2025-01-30 11:04
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='purchase',
+            name='price_per_game',
+            field=models.FloatField(null=True),
+        ),
+    ]

games/migrations/0003_alter_session_duration_manual_and_more.py

@@ -1,23 +0,0 @@
-# Generated by Django 4.1.4 on 2023-01-02 23:11
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0002_alter_session_duration_manual"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="session",
-            name="duration_manual",
-            field=models.DurationField(blank=True, null=True),
-        ),
-        migrations.AlterField(
-            model_name="session",
-            name="timestamp_end",
-            field=models.DateTimeField(blank=True, null=True),
-        ),
-    ]

games/migrations/0003_purchase_updated_at.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.5 on 2025-01-30 11:12
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0002_purchase_price_per_game'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='purchase',
+            name='updated_at',
+            field=models.DateTimeField(auto_now=True),
+        ),
+    ]

games/migrations/0004_alter_session_duration_manual.py

@@ -1,22 +0,0 @@
-# Generated by Django 4.1.5 on 2023-01-09 14:49
-
-import datetime
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0003_alter_session_duration_manual_and_more"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="session",
-            name="duration_manual",
-            field=models.DurationField(
-                blank=True, default=datetime.timedelta(0), null=True
-            ),
-        ),
-    ]

games/migrations/0004_purchase_num_purchases.py

@@ -0,0 +1,28 @@
+# Generated by Django 5.1.5 on 2025-01-30 11:57
+
+from django.db import migrations, models
+from django.db.models import Count
+
+
+def initialize_num_purchases(apps, schema_editor):
+    Purchase = apps.get_model("games", "Purchase")
+    purchases = Purchase.objects.annotate(num_games=Count("games"))
+
+    for purchase in purchases:
+        purchase.num_purchases = purchase.num_games
+        purchase.save(update_fields=["num_purchases"])
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0003_purchase_updated_at"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="purchase",
+            name="num_purchases",
+            field=models.IntegerField(default=0),
+        ),
+        migrations.RunPython(initialize_num_purchases),
+    ]

games/migrations/0005_auto_20230109_1843.py

@@ -1,35 +0,0 @@
-# Generated by Django 4.1.5 on 2023-01-09 17:43
-
-from datetime import timedelta
-
-from django.db import migrations
-
-
-def set_duration_calculated_none_to_zero(apps, schema_editor):
-    Session = apps.get_model("games", "Session")
-    for session in Session.objects.all():
-        if session.duration_calculated == None:
-            session.duration_calculated = timedelta(0)
-            session.save()
-
-
-def revert_set_duration_calculated_none_to_zero(apps, schema_editor):
-    Session = apps.get_model("games", "Session")
-    for session in Session.objects.all():
-        if session.duration_calculated == timedelta(0):
-            session.duration_calculated = None
-            session.save()
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0004_alter_session_duration_manual"),
-    ]
-
-    operations = [
-        migrations.RunPython(
-            set_duration_calculated_none_to_zero,
-            revert_set_duration_calculated_none_to_zero,
-        )
-    ]

games/migrations/0005_game_mastered_game_status.py

@@ -0,0 +1,38 @@
+# Generated by Django 5.1.5 on 2025-02-01 19:18
+
+from django.db import migrations, models
+
+
+def set_finished_status(apps, schema_editor):
+    Game = apps.get_model("games", "Game")
+    Game.objects.filter(purchases__date_finished__isnull=False).update(status="f")
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0004_purchase_num_purchases"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="game",
+            name="mastered",
+            field=models.BooleanField(default=False),
+        ),
+        migrations.AddField(
+            model_name="game",
+            name="status",
+            field=models.CharField(
+                choices=[
+                    ("u", "Unplayed"),
+                    ("p", "Played"),
+                    ("f", "Finished"),
+                    ("r", "Retired"),
+                    ("a", "Abandoned"),
+                ],
+                default="u",
+                max_length=1,
+            ),
+        ),
+        migrations.RunPython(set_finished_status),
+    ]

games/migrations/0006_alter_game_sort_name_alter_game_wikidata_and_more.py

@@ -0,0 +1,59 @@
+# Generated by Django 5.1.5 on 2025-03-01 12:52
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0005_game_mastered_game_status'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='game',
+            name='sort_name',
+            field=models.CharField(blank=True, default='', max_length=255),
+        ),
+        migrations.AlterField(
+            model_name='game',
+            name='wikidata',
+            field=models.CharField(blank=True, default='', max_length=50),
+        ),
+        migrations.AlterField(
+            model_name='platform',
+            name='group',
+            field=models.CharField(blank=True, default='', max_length=255),
+        ),
+        migrations.AlterField(
+            model_name='purchase',
+            name='converted_currency',
+            field=models.CharField(blank=True, default='', max_length=3),
+        ),
+        migrations.AlterField(
+            model_name='purchase',
+            name='games',
+            field=models.ManyToManyField(related_name='purchases', to='games.game'),
+        ),
+        migrations.AlterField(
+            model_name='purchase',
+            name='name',
+            field=models.CharField(blank=True, default='', max_length=255),
+        ),
+        migrations.AlterField(
+            model_name='purchase',
+            name='related_purchase',
+            field=models.ForeignKey(default=None, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='related_purchases', to='games.purchase'),
+        ),
+        migrations.AlterField(
+            model_name='session',
+            name='game',
+            field=models.ForeignKey(default=None, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='sessions', to='games.game'),
+        ),
+        migrations.AlterField(
+            model_name='session',
+            name='note',
+            field=models.TextField(blank=True, default=''),
+        ),
+    ]

games/migrations/0006_auto_20230109_1904.py

@@ -1,35 +0,0 @@
-# Generated by Django 4.1.5 on 2023-01-09 18:04
-
-from datetime import timedelta
-
-from django.db import migrations
-
-
-def set_duration_manual_none_to_zero(apps, schema_editor):
-    Session = apps.get_model("games", "Session")
-    for session in Session.objects.all():
-        if session.duration_manual == None:
-            session.duration_manual = timedelta(0)
-            session.save()
-
-
-def revert_set_duration_manual_none_to_zero(apps, schema_editor):
-    Session = apps.get_model("games", "Session")
-    for session in Session.objects.all():
-        if session.duration_manual == timedelta(0):
-            session.duration_manual = None
-            session.save()
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0005_auto_20230109_1843"),
-    ]
-
-    operations = [
-        migrations.RunPython(
-            set_duration_manual_none_to_zero,
-            revert_set_duration_manual_none_to_zero,
-        )
-    ]

games/migrations/0007_alter_purchase_game_alter_purchase_platform_and_more.py

@@ -1,35 +0,0 @@
-# Generated by Django 4.1.5 on 2023-01-19 18:30
-
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0006_auto_20230109_1904"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="purchase",
-            name="game",
-            field=models.ForeignKey(
-                on_delete=django.db.models.deletion.CASCADE, to="games.game"
-            ),
-        ),
-        migrations.AlterField(
-            model_name="purchase",
-            name="platform",
-            field=models.ForeignKey(
-                on_delete=django.db.models.deletion.CASCADE, to="games.platform"
-            ),
-        ),
-        migrations.AlterField(
-            model_name="session",
-            name="purchase",
-            field=models.ForeignKey(
-                on_delete=django.db.models.deletion.CASCADE, to="games.purchase"
-            ),
-        ),
-    ]

games/migrations/0007_game_updated_at.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.5 on 2025-03-17 07:36
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0006_alter_game_sort_name_alter_game_wikidata_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='game',
+            name='updated_at',
+            field=models.DateTimeField(auto_now=True),
+        ),
+    ]

games/migrations/0008_edition.py

@@ -1,41 +0,0 @@
-# Generated by Django 4.1.5 on 2023-02-18 16:29
-
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0007_alter_purchase_game_alter_purchase_platform_and_more"),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="Edition",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("name", models.CharField(max_length=255)),
-                (
-                    "game",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE, to="games.game"
-                    ),
-                ),
-                (
-                    "platform",
-                    models.ForeignKey(
-                        on_delete=django.db.models.deletion.CASCADE, to="games.platform"
-                    ),
-                ),
-            ],
-        ),
-    ]

games/migrations/0008_game_original_year_released_gamestatuschange_and_more.py

@@ -0,0 +1,190 @@
+# Generated by Django 5.1.7 on 2025-03-19 13:11
+
+import django.db.models.deletion
+import django.db.models.expressions
+from django.db import migrations, models
+from django.db.models import F, Min
+
+
+def copy_year_released(apps, schema_editor):
+    Game = apps.get_model("games", "Game")
+    Game.objects.update(original_year_released=F("year_released"))
+
+
+def set_abandoned_status(apps, schema_editor):
+    Game = apps.get_model("games", "Game")
+    Game = apps.get_model("games", "Game")
+    PlayEvent = apps.get_model("games", "PlayEvent")
+
+    Game.objects.filter(purchases__date_refunded__isnull=False).update(status="a")
+    Game.objects.filter(purchases__date_dropped__isnull=False).update(status="a")
+
+    finished = Game.objects.filter(purchases__date_finished__isnull=False)
+
+    for game in finished:
+        for purchase in game.purchases.all():
+            first_session = game.sessions.filter(
+                timestamp_start__gte=purchase.date_purchased
+            ).aggregate(Min("timestamp_start"))["timestamp_start__min"]
+            first_session_date = first_session.date() if first_session else None
+            if purchase.date_finished:
+                play_event = PlayEvent(
+                    game=game,
+                    started=first_session_date
+                    if first_session_date
+                    else purchase.date_purchased,
+                    ended=purchase.date_finished,
+                )
+                play_event.save()
+
+
+def create_game_status_changes(apps, schema_editor):
+    Game = apps.get_model("games", "Game")
+    GameStatusChange = apps.get_model("games", "GameStatusChange")
+
+    # if game has any sessions, find the earliest session and create a status change from unplayed to played with that sessions's timestamp_start
+    for game in Game.objects.filter(sessions__isnull=False).distinct():
+        if game.sessions.exists():
+            earliest_session = game.sessions.earliest()
+            GameStatusChange.objects.create(
+                game=game,
+                old_status="u",
+                new_status="p",
+                timestamp=earliest_session.timestamp_start,
+            )
+
+    for game in Game.objects.filter(purchases__date_dropped__isnull=False):
+        GameStatusChange.objects.create(
+            game=game,
+            old_status="p",
+            new_status="a",
+            timestamp=game.purchases.first().date_dropped,
+        )
+
+    for game in Game.objects.filter(purchases__date_refunded__isnull=False):
+        GameStatusChange.objects.create(
+            game=game,
+            old_status="p",
+            new_status="a",
+            timestamp=game.purchases.first().date_refunded,
+        )
+
+    # check if game has any playevents, if so create a status change from current status to finished based on playevent's ended date
+    # consider only the first playevent
+    for game in Game.objects.filter(playevents__isnull=False):
+        first_playevent = game.playevents.first()
+        GameStatusChange.objects.create(
+            game=game,
+            old_status="p",
+            new_status="f",
+            timestamp=first_playevent.ended,
+        )
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0007_game_updated_at"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="game",
+            name="original_year_released",
+            field=models.IntegerField(blank=True, default=None, null=True),
+        ),
+        migrations.RunPython(copy_year_released),
+        migrations.CreateModel(
+            name="GameStatusChange",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                (
+                    "old_status",
+                    models.CharField(
+                        blank=True,
+                        choices=[
+                            ("u", "Unplayed"),
+                            ("p", "Played"),
+                            ("f", "Finished"),
+                            ("r", "Retired"),
+                            ("a", "Abandoned"),
+                        ],
+                        max_length=1,
+                        null=True,
+                    ),
+                ),
+                (
+                    "new_status",
+                    models.CharField(
+                        choices=[
+                            ("u", "Unplayed"),
+                            ("p", "Played"),
+                            ("f", "Finished"),
+                            ("r", "Retired"),
+                            ("a", "Abandoned"),
+                        ],
+                        max_length=1,
+                    ),
+                ),
+                ("timestamp", models.DateTimeField(null=True)),
+                (
+                    "game",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="status_changes",
+                        to="games.game",
+                    ),
+                ),
+            ],
+            options={
+                "ordering": ["-timestamp"],
+            },
+        ),
+        migrations.CreateModel(
+            name="PlayEvent",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("started", models.DateField(blank=True, null=True)),
+                ("ended", models.DateField(blank=True, null=True)),
+                (
+                    "days_to_finish",
+                    models.GeneratedField(
+                        db_persist=True,
+                        expression=django.db.models.expressions.RawSQL(
+                            "\n            COALESCE(\n                CASE \n                    WHEN date(ended) = date(started) THEN 1\n                    ELSE julianday(ended) - julianday(started)\n                END, 0\n            )\n            ",
+                            [],
+                        ),
+                        output_field=models.IntegerField(),
+                    ),
+                ),
+                ("note", models.CharField(blank=True, default="", max_length=255)),
+                ("created_at", models.DateTimeField(auto_now_add=True)),
+                ("updated_at", models.DateTimeField(auto_now=True)),
+                (
+                    "game",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="playevents",
+                        to="games.game",
+                    ),
+                ),
+            ],
+        ),
+        migrations.RunPython(set_abandoned_status),
+        migrations.RunPython(create_game_status_changes),
+    ]

games/migrations/0009_create_editions.py

@@ -1,34 +0,0 @@
-# Generated by Django 4.1.5 on 2023-02-18 18:51
-
-from django.db import migrations
-
-
-def create_edition_of_game(apps, schema_editor):
-    Game = apps.get_model("games", "Game")
-    Edition = apps.get_model("games", "Edition")
-    Platform = apps.get_model("games", "Platform")
-    first_platform = Platform.objects.first()
-    all_games = Game.objects.all()
-    all_editions = Edition.objects.all()
-    for game in all_games:
-        existing_edition = None
-        try:
-            existing_edition = all_editions.objects.get(game=game.id)
-        except:
-            pass
-        if existing_edition == None:
-            edition = Edition()
-            edition.id = game.id
-            edition.game = game
-            edition.name = game.name
-            edition.platform = first_platform
-            edition.save()
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0008_edition"),
-    ]
-
-    operations = [migrations.RunPython(create_edition_of_game)]

games/migrations/0009_remove_purchase_date_dropped_and_more.py

@@ -0,0 +1,21 @@
+# Generated by Django 5.1.7 on 2025-03-20 11:35
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0008_game_original_year_released_gamestatuschange_and_more'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='purchase',
+            name='date_dropped',
+        ),
+        migrations.RemoveField(
+            model_name='purchase',
+            name='date_finished',
+        ),
+    ]

games/migrations/0010_alter_purchase_game.py

@@ -1,21 +0,0 @@
-# Generated by Django 4.1.5 on 2023-02-18 19:06
-
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0009_create_editions"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="purchase",
-            name="game",
-            field=models.ForeignKey(
-                on_delete=django.db.models.deletion.CASCADE, to="games.edition"
-            ),
-        ),
-    ]

games/migrations/0010_remove_purchase_price_per_game.py

@@ -0,0 +1,17 @@
+# Generated by Django 5.1.7 on 2025-03-22 17:46
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0009_remove_purchase_date_dropped_and_more'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='purchase',
+            name='price_per_game',
+        ),
+    ]

games/migrations/0011_purchase_price_per_game.py

@@ -0,0 +1,20 @@
+# Generated by Django 5.1.7 on 2025-03-22 17:46
+
+import django.db.models.expressions
+import django.db.models.functions.comparison
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0010_remove_purchase_price_per_game'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='purchase',
+            name='price_per_game',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(django.db.models.functions.comparison.Coalesce(models.F('converted_price'), models.F('price'), 0), '/', models.F('num_purchases')), output_field=models.FloatField()),
+        ),
+    ]

games/migrations/0011_rename_game_purchase_edition.py

@@ -1,18 +0,0 @@
-# Generated by Django 4.1.5 on 2023-02-18 19:18
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0010_alter_purchase_game"),
-    ]
-
-    operations = [
-        migrations.RenameField(
-            model_name="purchase",
-            old_name="game",
-            new_name="edition",
-        ),
-    ]

games/migrations/0012_alter_session_duration_calculated.py

@@ -0,0 +1,32 @@
+# Generated by Django 5.1.7 on 2025-03-25 20:30
+
+import django.db.models.expressions
+import django.db.models.functions.comparison
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0011_purchase_price_per_game"),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name="session",
+            name="duration_calculated",
+        ),
+        migrations.AddField(
+            model_name="session",
+            name="duration_calculated",
+            field=models.GeneratedField(
+                db_persist=True,
+                expression=django.db.models.functions.comparison.Coalesce(
+                    django.db.models.expressions.CombinedExpression(
+                        models.F("timestamp_end"), "-", models.F("timestamp_start")
+                    ),
+                    0,
+                ),
+                output_field=models.DurationField(),
+            ),
+        ),
+    ]

games/migrations/0013_game_playtime.py

@@ -0,0 +1,35 @@
+# Generated by Django 5.1.7 on 2025-03-25 20:33
+
+import datetime
+
+from django.db import migrations, models
+from django.db.models import F, Sum
+
+
+def calculate_game_playtime(apps, schema_editor):
+    Game = apps.get_model("games", "Game")
+    games = Game.objects.all()
+    for game in games:
+        total_playtime = game.sessions.aggregate(
+            total_playtime=Sum(F("duration_total"))
+        )["total_playtime"]
+        if total_playtime:
+            game.playtime = total_playtime
+            game.save(update_fields=["playtime"])
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0012_alter_session_duration_calculated"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="game",
+            name="playtime",
+            field=models.DurationField(
+                blank=True, default=datetime.timedelta(0), editable=False
+            ),
+        ),
+        migrations.RunPython(calculate_game_playtime),
+    ]

games/migrations/0014_session_duration_total.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.1.7 on 2025-03-25 20:46
+
+import django.db.models.expressions
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0013_game_playtime'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='session',
+            name='duration_total',
+            field=models.GeneratedField(db_persist=True, expression=django.db.models.expressions.CombinedExpression(models.F('duration_calculated'), '+', models.F('duration_manual')), output_field=models.DurationField()),
+        ),
+    ]

games/models.py

@@ -1,96 +1,483 @@
-from datetime import datetime, timedelta
-from typing import Any
-from zoneinfo import ZoneInfo
+import logging
+from datetime import timedelta
+
+import requests
+from django.core.exceptions import ValidationError
+from django.db import models
+from django.db.models import F, Sum
+from django.db.models.expressions import RawSQL
+from django.db.models.fields.generated import GeneratedField
+from django.db.models.functions import Coalesce
+from django.template.defaultfilters import floatformat, pluralize, slugify
+from django.utils import timezone
 
 from common.time import format_duration
-from django.conf import settings
-from django.db import models
-from django.db.models import F, Manager, Sum
+
+logger = logging.getLogger("games")
 
 
 class Game(models.Model):
+    class Meta:
+        unique_together = [["name", "platform", "year_released"]]
+
     name = models.CharField(max_length=255)
-    wikidata = models.CharField(max_length=50)
+    sort_name = models.CharField(max_length=255, blank=True, default="")
+    year_released = models.IntegerField(null=True, blank=True, default=None)
+    original_year_released = models.IntegerField(null=True, blank=True, default=None)
+    wikidata = models.CharField(max_length=50, blank=True, default="")
+    platform = models.ForeignKey(
+        "Platform", on_delete=models.SET_DEFAULT, null=True, blank=True, default=None
+    )
+
+    playtime = models.DurationField(blank=True, editable=False, default=timedelta(0))
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Status(models.TextChoices):
+        UNPLAYED = (
+            "u",
+            "Unplayed",
+        )
+        PLAYED = (
+            "p",
+            "Played",
+        )
+        FINISHED = (
+            "f",
+            "Finished",
+        )
+        RETIRED = (
+            "r",
+            "Retired",
+        )
+        ABANDONED = (
+            "a",
+            "Abandoned",
+        )
+
+    status = models.CharField(max_length=1, choices=Status, default=Status.UNPLAYED)
+    mastered = models.BooleanField(default=False)
+
+    session_average: float | int | timedelta | None
+    session_count: int | None
 
     def __str__(self):
         return self.name
 
+    def finished(self):
+        return self.status == self.Status.FINISHED
 
-class Edition(models.Model):
-    game = models.ForeignKey("Game", on_delete=models.CASCADE)
-    name = models.CharField(max_length=255)
-    platform = models.ForeignKey("Platform", on_delete=models.CASCADE)
+    def abandoned(self):
+        return self.status == self.Status.ABANDONED
 
-    def __str__(self):
-        return self.name
+    def retired(self):
+        return self.status == self.Status.RETIRED
+
+    def played(self):
+        return self.status == self.Status.PLAYED
+
+    def unplayed(self):
+        return self.status == self.Status.UNPLAYED
+
+    def playtime_formatted(self):
+        return format_duration(self.playtime, "%2.1H")
+
+    def save(self, *args, **kwargs):
+        if self.platform is None:
+            self.platform = get_sentinel_platform()
+        super().save(*args, **kwargs)
 
 
-class Purchase(models.Model):
-    edition = models.ForeignKey("Edition", on_delete=models.CASCADE)
-    platform = models.ForeignKey("Platform", on_delete=models.CASCADE)
-    date_purchased = models.DateField()
-    date_refunded = models.DateField(blank=True, null=True)
-
-    def __str__(self):
-        return f"{self.edition} ({self.platform})"
+def get_sentinel_platform():
+    return Platform.objects.get_or_create(
+        name="Unspecified", icon="unspecified", group="Unspecified"
+    )[0]
 
 
 class Platform(models.Model):
     name = models.CharField(max_length=255)
-    group = models.CharField(max_length=255)
+    group = models.CharField(max_length=255, blank=True, default="")
+    icon = models.SlugField(blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
 
     def __str__(self):
         return self.name
 
+    def save(self, *args, **kwargs):
+        if not self.icon:
+            self.icon = slugify(self.name)
+        super().save(*args, **kwargs)
+
+
+class PurchaseQueryset(models.QuerySet):
+    def refunded(self):
+        return self.filter(date_refunded__isnull=False)
+
+    def not_refunded(self):
+        return self.filter(date_refunded__isnull=True)
+
+    def games_only(self):
+        return self.filter(type=Purchase.GAME)
+
+
+class Purchase(models.Model):
+    PHYSICAL = "ph"
+    DIGITAL = "di"
+    DIGITALUPGRADE = "du"
+    RENTED = "re"
+    BORROWED = "bo"
+    TRIAL = "tr"
+    DEMO = "de"
+    PIRATED = "pi"
+    OWNERSHIP_TYPES = [
+        (PHYSICAL, "Physical"),
+        (DIGITAL, "Digital"),
+        (DIGITALUPGRADE, "Digital Upgrade"),
+        (RENTED, "Rented"),
+        (BORROWED, "Borrowed"),
+        (TRIAL, "Trial"),
+        (DEMO, "Demo"),
+        (PIRATED, "Pirated"),
+    ]
+    GAME = "game"
+    DLC = "dlc"
+    SEASONPASS = "season_pass"
+    BATTLEPASS = "battle_pass"
+    TYPES = [
+        (GAME, "Game"),
+        (DLC, "DLC"),
+        (SEASONPASS, "Season Pass"),
+        (BATTLEPASS, "Battle Pass"),
+    ]
+
+    objects = PurchaseQueryset().as_manager()
+
+    games = models.ManyToManyField(Game, related_name="purchases")
+
+    platform = models.ForeignKey(
+        Platform, on_delete=models.CASCADE, default=None, null=True, blank=True
+    )
+    date_purchased = models.DateField(verbose_name="Purchased")
+    date_refunded = models.DateField(blank=True, null=True, verbose_name="Refunded")
+    infinite = models.BooleanField(default=False)
+    price = models.FloatField(default=0)
+    price_currency = models.CharField(max_length=3, default="USD")
+    converted_price = models.FloatField(null=True)
+    converted_currency = models.CharField(max_length=3, blank=True, default="")
+    price_per_game = GeneratedField(
+        expression=Coalesce(F("converted_price"), F("price"), 0) / F("num_purchases"),
+        output_field=models.FloatField(),
+        db_persist=True,
+        editable=False,
+    )
+    num_purchases = models.IntegerField(default=0)
+    ownership_type = models.CharField(
+        max_length=2, choices=OWNERSHIP_TYPES, default=DIGITAL
+    )
+    type = models.CharField(max_length=255, choices=TYPES, default=GAME)
+    name = models.CharField(max_length=255, blank=True, default="")
+    related_purchase = models.ForeignKey(
+        "self",
+        on_delete=models.SET_NULL,
+        default=None,
+        null=True,
+        related_name="related_purchases",
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    @property
+    def standardized_price(self):
+        return (
+            f"{floatformat(self.converted_price, 0)} {self.converted_currency}"
+            if self.converted_price
+            else None
+        )
+
+    @property
+    def has_one_item(self):
+        return self.games.count() == 1
+
+    @property
+    def standardized_name(self):
+        return self.name or self.first_game.name
+
+    @property
+    def first_game(self):
+        return self.games.first()
+
+    def __str__(self):
+        return self.standardized_name
+
+    @property
+    def full_name(self):
+        additional_info = [
+            str(item)
+            for item in [
+                f"{self.num_purchases} game{pluralize(self.num_purchases)}",
+                self.date_purchased,
+                self.standardized_price,
+            ]
+            if item
+        ]
+        return f"{self.standardized_name} ({', '.join(additional_info)})"
+
+    def is_game(self):
+        return self.type == self.GAME
+
+    def price_or_currency_differ_from(self, purchase_to_compare):
+        return (
+            self.price != purchase_to_compare.price
+            or self.price_currency != purchase_to_compare.price_currency
+        )
+
+    def save(self, *args, **kwargs):
+        if self.type != Purchase.GAME and not self.related_purchase:
+            raise ValidationError(
+                f"{self.get_type_display()} must have a related purchase."
+            )
+        if self.pk is not None:
+            # Retrieve the existing instance from the database
+            existing_purchase = Purchase.objects.get(pk=self.pk)
+            # If price has changed, reset converted fields
+            if existing_purchase.price_or_currency_differ_from(self):
+                from games.tasks import currency_to
+
+                exchange_rate = get_or_create_rate(
+                    self.price_currency, currency_to, self.date_purchased.year
+                )
+                if exchange_rate:
+                    self.converted_price = floatformat(self.price * exchange_rate, 0)
+                    self.converted_currency = currency_to
+        super().save(*args, **kwargs)
+
 
 class SessionQuerySet(models.QuerySet):
-    def total_duration(self):
+    def total_duration_formatted(self):
+        return format_duration(self.total_duration_unformatted())
+
+    def total_duration_unformatted(self):
         result = self.aggregate(
             duration=Sum(F("duration_calculated") + F("duration_manual"))
         )
-        return format_duration(result["duration"])
+        return result["duration"]
+
+    def calculated_duration_formatted(self):
+        return format_duration(self.calculated_duration_unformatted())
+
+    def calculated_duration_unformatted(self):
+        result = self.aggregate(duration=Sum(F("duration_calculated")))
+        return result["duration"]
+
+    def without_manual(self):
+        return self.exclude(duration_calculated__iexact=0)
+
+    def only_manual(self):
+        return self.filter(duration_calculated__iexact=0)
 
 
 class Session(models.Model):
-    purchase = models.ForeignKey("Purchase", on_delete=models.CASCADE)
-    timestamp_start = models.DateTimeField()
-    timestamp_end = models.DateTimeField(blank=True, null=True)
-    duration_manual = models.DurationField(blank=True, null=True, default=timedelta(0))
-    duration_calculated = models.DurationField(blank=True, null=True)
-    note = models.TextField(blank=True, null=True)
+    class Meta:
+        get_latest_by = "timestamp_start"
+
+    game = models.ForeignKey(
+        Game,
+        on_delete=models.CASCADE,
+        null=True,
+        default=None,
+        related_name="sessions",
+    )
+    timestamp_start = models.DateTimeField(verbose_name="Start")
+    timestamp_end = models.DateTimeField(blank=True, null=True, verbose_name="End")
+    duration_manual = models.DurationField(
+        blank=True, null=True, default=timedelta(0), verbose_name="Manual duration"
+    )
+    duration_calculated = GeneratedField(
+        expression=Coalesce(F("timestamp_end") - F("timestamp_start"), 0),
+        output_field=models.DurationField(),
+        db_persist=True,
+        editable=False,
+    )
+    duration_total = GeneratedField(
+        expression=F("duration_calculated") + F("duration_manual"),
+        output_field=models.DurationField(),
+        db_persist=True,
+        editable=False,
+    )
+    device = models.ForeignKey(
+        "Device",
+        on_delete=models.SET_DEFAULT,
+        null=True,
+        blank=True,
+        default=None,
+    )
+    note = models.TextField(blank=True, default="")
+    emulated = models.BooleanField(default=False)
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    modified_at = models.DateTimeField(auto_now=True)
 
     objects = SessionQuerySet.as_manager()
 
     def __str__(self):
-        mark = ", manual" if self.duration_manual != None else ""
-        return f"{str(self.purchase)} {str(self.timestamp_start.date())} ({self.duration_formatted()}{mark})"
+        mark = "*" if self.is_manual() else ""
+        return f"{str(self.game)} {str(self.timestamp_start.date())} ({self.duration_formatted()}{mark})"
 
     def finish_now(self):
-        self.timestamp_end = datetime.now(ZoneInfo(settings.TIME_ZONE))
+        self.timestamp_end = timezone.now()
 
     def start_now():
-        self.timestamp_start = datetime.now(ZoneInfo(settings.TIME_ZONE))
-
-    def duration_seconds(self) -> timedelta:
-        manual = timedelta(0)
-        calculated = timedelta(0)
-        if not self.duration_manual in (None, 0, timedelta(0)):
-            manual = self.duration_manual
-        if self.timestamp_end != None and self.timestamp_start != None:
-            calculated = self.timestamp_end - self.timestamp_start
-        return timedelta(seconds=(manual + calculated).total_seconds())
+        self.timestamp_start = timezone.now()
 
     def duration_formatted(self) -> str:
-        result = format_duration(self.duration_seconds(), "%H:%m")
+        result = format_duration(self.duration_total, "%02.1H")
         return result
 
-    @property
-    def duration_sum(self) -> str:
-        return Session.objects.all().total_duration()
+    def duration_formatted_with_mark(self) -> str:
+        mark = "*" if self.is_manual() else ""
+        return f"{self.duration_formatted()}{mark}"
 
-    def save(self, *args, **kwargs):
-        if self.timestamp_start != None and self.timestamp_end != None:
-            self.duration_calculated = self.timestamp_end - self.timestamp_start
-        else:
-            self.duration_calculated = timedelta(0)
+    def is_manual(self) -> bool:
+        return not self.duration_manual == timedelta(0)
+
+    def save(self, *args, **kwargs) -> None:
+        if not isinstance(self.duration_manual, timedelta):
+            self.duration_manual = timedelta(0)
+
+        if not self.device:
+            default_device, _ = Device.objects.get_or_create(
+                type=Device.UNKNOWN, defaults={"name": "Unknown"}
+            )
+            self.device = default_device
         super(Session, self).save(*args, **kwargs)
+
+
+class Device(models.Model):
+    PC = "PC"
+    CONSOLE = "Console"
+    HANDHELD = "Handheld"
+    MOBILE = "Mobile"
+    SBC = "Single-board computer"
+    UNKNOWN = "Unknown"
+    DEVICE_TYPES = [
+        (PC, "PC"),
+        (CONSOLE, "Console"),
+        (HANDHELD, "Handheld"),
+        (MOBILE, "Mobile"),
+        (SBC, "Single-board computer"),
+        (UNKNOWN, "Unknown"),
+    ]
+    name = models.CharField(max_length=255)
+    type = models.CharField(max_length=255, choices=DEVICE_TYPES, default=UNKNOWN)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    def __str__(self):
+        return f"{self.name} ({self.type})"
+
+
+class ExchangeRate(models.Model):
+    currency_from = models.CharField(max_length=255)
+    currency_to = models.CharField(max_length=255)
+    year = models.PositiveIntegerField()
+    rate = models.FloatField()
+
+    class Meta:
+        unique_together = ("currency_from", "currency_to", "year")
+
+    def __str__(self):
+        return f"{self.currency_from}/{self.currency_to} - {self.rate} ({self.year})"
+
+
+def get_or_create_rate(currency_from: str, currency_to: str, year: int) -> float | None:
+    exchange_rate = None
+    result = ExchangeRate.objects.filter(
+        currency_from=currency_from, currency_to=currency_to, year=year
+    )
+    if result:
+        exchange_rate = result[0].rate
+    else:
+        try:
+            # this API endpoint only accepts lowercase currency string
+            response = requests.get(
+                f"https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@{year}-01-01/v1/currencies/{currency_from.lower()}.json"
+            )
+            response.raise_for_status()
+            data = response.json()
+            currency_from_data = data.get(currency_from.lower())
+            rate = currency_from_data.get(currency_to.lower())
+
+            if rate:
+                logger.info(f"[convert_prices]: Got {rate}, saving...")
+                exchange_rate = ExchangeRate.objects.create(
+                    currency_from=currency_from,
+                    currency_to=currency_to,
+                    year=year,
+                    rate=floatformat(rate, 2),
+                )
+                exchange_rate = exchange_rate.rate
+            else:
+                logger.info("[convert_prices]: Could not get an exchange rate.")
+        except requests.RequestException as e:
+            logger.info(
+                f"[convert_prices]: Failed to fetch exchange rate for {currency_from}->{currency_to} in {year}: {e}"
+            )
+    return exchange_rate
+
+
+class PlayEvent(models.Model):
+    game = models.ForeignKey(Game, related_name="playevents", on_delete=models.CASCADE)
+    started = models.DateField(null=True, blank=True)
+    ended = models.DateField(null=True, blank=True)
+    days_to_finish = GeneratedField(
+        # special cases:
+        # missing ended, started, or both = 0
+        # same day = 1 day to finish
+        expression=RawSQL(
+            """
+            COALESCE(
+                CASE 
+                    WHEN date(ended) = date(started) THEN 1
+                    ELSE julianday(ended) - julianday(started)
+                END, 0
+            )
+            """,
+            [],
+        ),
+        output_field=models.IntegerField(),
+        db_persist=True,
+        editable=False,
+        blank=True,
+    )
+    note = models.CharField(max_length=255, blank=True, default="")
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+
+# class PlayMarker(models.Model):
+#     game = models.ForeignKey(Game, related_name="markers", on_delete=models.CASCADE)
+#     played_since = models.DurationField()
+#     played_total = models.DurationField()
+#     note = models.CharField(max_length=255)
+
+
+class GameStatusChange(models.Model):
+    """
+    Tracks changes to the status of a Game.
+    """
+
+    game = models.ForeignKey(
+        Game, on_delete=models.CASCADE, related_name="status_changes"
+    )
+    old_status = models.CharField(
+        max_length=1, choices=Game.Status.choices, blank=True, null=True
+    )
+    new_status = models.CharField(max_length=1, choices=Game.Status.choices)
+    timestamp = models.DateTimeField(null=True)
+
+    def __str__(self):
+        return f"{self.game.name}: {self.old_status or 'None'} -> {self.new_status} at {self.timestamp}"
+
+    class Meta:
+        ordering = ["-timestamp"]

games/schema.py

@@ -0,0 +1,30 @@
+import graphene
+
+from games.graphql.mutations import GameMutation
+from games.graphql.queries import (
+    DeviceQuery,
+    EditionQuery,
+    GameQuery,
+    PlatformQuery,
+    PurchaseQuery,
+    SessionQuery,
+)
+
+
+class Query(
+    GameQuery,
+    EditionQuery,
+    DeviceQuery,
+    PlatformQuery,
+    PurchaseQuery,
+    SessionQuery,
+    graphene.ObjectType,
+):
+    pass
+
+
+class Mutation(GameMutation, graphene.ObjectType):
+    pass
+
+
+schema = graphene.Schema(query=Query, mutation=Mutation)

games/signals.py

@@ -0,0 +1,58 @@
+import logging
+from datetime import timedelta
+
+from django.db.models import F, Sum
+from django.db.models.signals import m2m_changed, post_delete, post_save, pre_save
+from django.dispatch import receiver
+from django.utils.timezone import now
+
+from games.models import Game, GameStatusChange, Purchase, Session
+
+logger = logging.getLogger("games")
+
+
+@receiver(m2m_changed, sender=Purchase.games.through)
+def update_num_purchases(sender, instance, **kwargs):
+    instance.num_purchases = instance.games.count()
+    instance.updated_at = now()
+    instance.save(update_fields=["num_purchases"])
+
+
+@receiver([post_save, post_delete], sender=Session)
+def update_game_playtime(sender, instance, **kwargs):
+    game = instance.game
+    total_playtime = game.sessions.aggregate(
+        total_playtime=Sum(F("duration_calculated") + F("duration_manual"))
+    )["total_playtime"]
+    game.playtime = total_playtime if total_playtime else timedelta(0)
+    game.save(update_fields=["playtime"])
+
+
+@receiver(pre_save, sender=Game)
+def game_status_changed(sender, instance, **kwargs):
+    """
+    Signal handler to create a GameStatusChange record whenever a Game's status is updated.
+    """
+    try:
+        old_instance = sender.objects.get(pk=instance.pk)
+        old_status = old_instance.status
+        logger.info("[game_status_changed]: Previous status exists.")
+    except sender.DoesNotExist:
+        # Handle the case where the instance was deleted before the signal was sent
+        logger.info("[game_status_changed]: Previous status does not exist.")
+        return
+
+    if old_status != instance.status:
+        logger.info(
+            "[game_status_changed]: Status changed from {} to {}".format(
+                old_status, instance.status
+            )
+        )
+        GameStatusChange.objects.create(
+            game=instance,
+            old_status=old_status,
+            new_status=instance.status,
+            timestamp=now(),
+        )
+    else:
+        logger.info("[game_status_changed]: Status has not changed")

games/static/js/add_edition.js

@@ -0,0 +1,24 @@
+import { syncSelectInputUntilChanged } from "./utils.js";
+
+let syncData = [
+  {
+    source: "#id_game",
+    source_value: "dataset.name",
+    target: "#id_name",
+    target_value: "value",
+  },
+  {
+    source: "#id_game",
+    source_value: "textContent",
+    target: "#id_sort_name",
+    target_value: "value",
+  },
+  {
+    source: "#id_game",
+    source_value: "dataset.year",
+    target: "#id_year_released",
+    target_value: "value",
+  },
+];
+
+syncSelectInputUntilChanged(syncData, "form");

games/static/js/add_game.js

@@ -0,0 +1,12 @@
+import { syncSelectInputUntilChanged } from "./utils.js";
+
+let syncData = [
+  {
+    source: "#id_name",
+    source_value: "value",
+    target: "#id_sort_name",
+    target_value: "value",
+  },
+];
+
+syncSelectInputUntilChanged(syncData, "form");

games/static/js/add_purchase.js

@@ -0,0 +1,42 @@
+import {
+  syncSelectInputUntilChanged,
+  getEl,
+  disableElementsWhenTrue,
+  disableElementsWhenValueNotEqual,
+} from "./utils.js";
+
+let syncData = [
+  {
+    source: "#id_games",
+    source_value: "dataset.platform",
+    target: "#id_platform",
+    target_value: "value",
+  },
+];
+
+syncSelectInputUntilChanged(syncData, "form");
+
+function setupElementHandlers() {
+  disableElementsWhenTrue("#id_type", "game", [
+    "#id_name",
+    "#id_related_purchase",
+  ]);
+}
+
+document.addEventListener("DOMContentLoaded", setupElementHandlers);
+document.addEventListener("htmx:afterSwap", setupElementHandlers);
+getEl("#id_type").onchange = () => {
+  setupElementHandlers();
+};
+
+document.body.addEventListener("htmx:beforeRequest", function (event) {
+  // Assuming 'Purchase1' is the element that triggers the HTMX request
+  if (event.target.id === "id_games") {
+    var idEditionValue = document.getElementById("id_games").value;
+
+    // Condition to check - replace this with your actual logic
+    if (idEditionValue != "") {
+      event.preventDefault(); // This cancels the HTMX request
+    }
+  }
+});

games/static/js/add_session.js

@@ -0,0 +1,23 @@
+import { toISOUTCString } from "./utils.js";
+
+for (let button of document.querySelectorAll("[data-target]")) {
+  let target = button.getAttribute("data-target");
+  let type = button.getAttribute("data-type");
+  let targetElement = document.querySelector(`#id_${target}`);
+  button.addEventListener("click", (event) => {
+    event.preventDefault();
+    if (type == "now") {
+      targetElement.value = toISOUTCString(new Date());
+    } else if (type == "copy") {
+      const oppositeName =
+        targetElement.name == "timestamp_start"
+          ? "timestamp_end"
+          : "timestamp_start";
+      document.querySelector(`[name='${oppositeName}']`).value =
+        targetElement.value;
+    } else if (type == "toggle") {
+      if (targetElement.type == "datetime-local") targetElement.type = "text";
+      else targetElement.type = "datetime-local";
+    }
+  });
+}

games/static/js/utils.js

@@ -0,0 +1,207 @@
+/**
+ * @description Formats Date to a UTC string accepted by the datetime-local input field.
+ * @param {Date} date
+ * @returns {string}
+ */
+function toISOUTCString(date) {
+  function stringAndPad(number) {
+    return number.toString().padStart(2, 0);
+  }
+  const year = date.getFullYear();
+  const month = stringAndPad(date.getMonth() + 1);
+  const day = stringAndPad(date.getDate());
+  const hours = stringAndPad(date.getHours());
+  const minutes = stringAndPad(date.getMinutes());
+  return `${year}-${month}-${day}T${hours}:${minutes}`;
+}
+
+/**
+ * @description Sync values between source and target elements based on syncData configuration.
+ * @param {Array} syncData - Array of objects to define source and target elements with their respective value types.
+ */
+function syncSelectInputUntilChanged(syncData, parentSelector = document) {
+  const parentElement =
+    parentSelector === document
+      ? document
+      : document.querySelector(parentSelector);
+
+  if (!parentElement) {
+    console.error(`The parent selector "${parentSelector}" is not valid.`);
+    return;
+  }
+  // Set up a single change event listener on the document for handling all source changes
+  parentElement.addEventListener("change", function (event) {
+    // Loop through each sync configuration item
+    syncData.forEach((syncItem) => {
+      // Check if the change event target matches the source selector
+      if (event.target.matches(syncItem.source)) {
+        const sourceElement = event.target;
+        const valueToSync = getValueFromProperty(
+          sourceElement,
+          syncItem.source_value
+        );
+        const targetElement = document.querySelector(syncItem.target);
+
+        if (targetElement && valueToSync !== null) {
+          targetElement[syncItem.target_value] = valueToSync;
+        }
+      }
+    });
+  });
+
+  // Set up a single focus event listener on the document for handling all target focuses
+  parentElement.addEventListener(
+    "focus",
+    function (event) {
+      // Loop through each sync configuration item
+      syncData.forEach((syncItem) => {
+        // Check if the focus event target matches the target selector
+        if (event.target.matches(syncItem.target)) {
+          // Remove the change event listener to stop syncing
+          // This assumes you want to stop syncing once any target receives focus
+          // You may need a more sophisticated way to remove listeners if you want to stop
+          // syncing selectively based on other conditions
+          document.removeEventListener("change", syncSelectInputUntilChanged);
+        }
+      });
+    },
+    true
+  ); // Use capture phase to ensure the event is captured during focus, not bubble
+}
+
+/**
+ * @description Retrieve the value from the source element based on the provided property.
+ * @param {Element} sourceElement - The source HTML element.
+ * @param {string} property - The property to retrieve the value from.
+ */
+function getValueFromProperty(sourceElement, property) {
+  let source =
+    sourceElement instanceof HTMLSelectElement
+      ? sourceElement.selectedOptions[0]
+      : sourceElement;
+  if (property.startsWith("dataset.")) {
+    let datasetKey = property.slice(8); // Remove 'dataset.' part
+    return source.dataset[datasetKey];
+  } else if (property in source) {
+    return source[property];
+  } else {
+    console.error(`Property ${property} is not valid for the option element.`);
+    return null;
+  }
+}
+
+/**
+ * @description Returns a single element by name.
+ * @param {string} selector The selector to look for.
+ */
+function getEl(selector) {
+  if (selector.startsWith("#")) {
+    return document.getElementById(selector.slice(1));
+  } else if (selector.startsWith(".")) {
+    return document.getElementsByClassName(selector);
+  } else {
+    return document.getElementsByTagName(selector);
+  }
+}
+
+/**
+ * @description Applies different behaviors to elements based on multiple conditional configurations.
+ * Each configuration is an array containing a condition function, an array of target element selectors,
+ * and two callback functions for handling matched and unmatched conditions.
+ * @param {...Array} configs Each configuration is an array of the form:
+ *   - 0: {function(): boolean} condition - Function that returns true or false based on a condition.
+ *   - 1: {string[]} targetElements - Array of CSS selectors for target elements.
+ *   - 2: {function(HTMLElement): void} callbackfn1 - Function to execute when condition is true.
+ *   - 3: {function(HTMLElement): void} callbackfn2 - Function to execute when condition is false.
+ */
+function conditionalElementHandler(...configs) {
+  configs.forEach(([condition, targetElements, callbackfn1, callbackfn2]) => {
+    if (condition()) {
+      targetElements.forEach((elementName) => {
+        let el = getEl(elementName);
+        if (el === null) {
+          console.error(`Element ${elementName} doesn't exist.`);
+        } else {
+          callbackfn1(el);
+        }
+      });
+    } else {
+      targetElements.forEach((elementName) => {
+        let el = getEl(elementName);
+        if (el === null) {
+          console.error(`Element ${elementName} doesn't exist.`);
+        } else {
+          callbackfn2(el);
+        }
+      });
+    }
+  });
+}
+
+function disableElementsWhenValueNotEqual(
+  targetSelect,
+  targetValue,
+  elementList
+) {
+  return conditionalElementHandler([
+    () => {
+      let target = getEl(targetSelect);
+      console.debug(
+        `${disableElementsWhenTrue.name}: triggered on ${target.id}`
+      );
+      console.debug(`
+      ${disableElementsWhenTrue.name}: matching against value(s): ${targetValue}`);
+      if (targetValue instanceof Array) {
+        if (targetValue.every((value) => target.value != value)) {
+          console.debug(
+            `${disableElementsWhenTrue.name}: none of the values is equal to ${target.value}, returning true.`
+          );
+          return true;
+        }
+      } else {
+        console.debug(
+          `${disableElementsWhenTrue.name}: none of the values is equal to ${target.value}, returning true.`
+        );
+        return target.value != targetValue;
+      }
+    },
+    elementList,
+    (el) => {
+      console.debug(
+        `${disableElementsWhenTrue.name}: evaluated true, disabling ${el.id}.`
+      );
+      el.disabled = "disabled";
+    },
+    (el) => {
+      console.debug(
+        `${disableElementsWhenTrue.name}: evaluated false, NOT disabling ${el.id}.`
+      );
+      el.disabled = "";
+    },
+  ]);
+}
+
+function disableElementsWhenTrue(targetSelect, targetValue, elementList) {
+  return conditionalElementHandler([
+    () => {
+      return getEl(targetSelect).value == targetValue;
+    },
+    elementList,
+    (el) => {
+      el.disabled = "disabled";
+    },
+    (el) => {
+      el.disabled = "";
+    },
+  ]);
+}
+
+export {
+  toISOUTCString,
+  syncSelectInputUntilChanged,
+  getEl,
+  conditionalElementHandler,
+  disableElementsWhenValueNotEqual,
+  disableElementsWhenTrue,
+  getValueFromProperty,
+};

games/static/main.js

@@ -0,0 +1,43 @@
+function elt(type, props, ...children) {
+  let dom = document.createElement(type);
+  if (props) Object.assign(dom, props);
+  for (let child of children) {
+    if (typeof child != "string") dom.appendChild(child);
+    else dom.appendChild(document.createTextNode(child));
+  }
+  return dom;
+}
+
+/**
+ * @param {Node} targetNode
+ */
+function addToggleButton(targetNode) {
+  let manualToggleButton = elt(
+    "td",
+    {},
+    elt(
+      "div",
+      { className: "basic-button" },
+      elt(
+        "button",
+        {
+          onclick: (event) => {
+            let textInputField = elt("input", { type: "text", id: targetNode.id });
+            targetNode.replaceWith(textInputField);
+            event.target.addEventListener("click", (event) => {
+              textInputField.replaceWith(targetNode);
+            });
+          },
+        },
+        "Toggle manual"
+      )
+    )
+  );
+  targetNode.parentElement.appendChild(manualToggleButton);
+}
+
+const toggleableFields = ["#id_games", "#id_platform"];
+
+toggleableFields.map((selector) => {
+  addToggleButton(document.querySelector(selector));
+});

games/static/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /

games/tasks.py

@@ -0,0 +1,94 @@
+import requests
+from django.db.models import ExpressionWrapper, F, FloatField, Q
+from django.template.defaultfilters import floatformat
+from django.utils.timezone import now
+from django_q.models import Task
+import logging
+
+logger = logging.getLogger("games")
+
+from games.models import ExchangeRate, Purchase
+
+# fixme: save preferred currency in user model
+currency_to = "CZK"
+currency_to = currency_to.upper()
+
+
+def save_converted_info(purchase, converted_price, converted_currency):
+    logger.info(
+        f"Setting converted price of {purchase} to {converted_price} {converted_currency} (originally {purchase.price} {purchase.price_currency})"
+    )
+    purchase.converted_price = converted_price
+    purchase.converted_currency = converted_currency
+    purchase.save()
+
+
+def convert_prices():
+    purchases = Purchase.objects.filter(
+        converted_price__isnull=True, converted_currency=""
+    )
+    if purchases.count() == 0:
+        logger.info("[convert_prices]: No prices to convert.")
+
+    for purchase in purchases:
+        if purchase.price_currency.upper() == currency_to or purchase.price == 0:
+            save_converted_info(purchase, purchase.price, currency_to)
+            continue
+        year = purchase.date_purchased.year
+        currency_from = purchase.price_currency.upper()
+
+        exchange_rate = ExchangeRate.objects.filter(
+            currency_from=currency_from, currency_to=currency_to, year=year
+        ).first()
+        logger.info(f"[convert_prices]: Looking for exchange rate in database: {currency_from}->{currency_to}")
+        if not exchange_rate:
+            logger.info(
+                f"[convert_prices]: Getting exchange rate from {currency_from} to {currency_to} for {year}..."
+            )
+            try:
+                # this API endpoint only accepts lowercase currency string
+                response = requests.get(
+                    f"https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@{year}-01-01/v1/currencies/{currency_from.lower()}.json"
+                )
+                response.raise_for_status()
+                data = response.json()
+                currency_from_data = data.get(currency_from.lower())
+                rate = currency_from_data.get(currency_to.lower())
+
+                if rate:
+                    logger.info(f"[convert_prices]: Got {rate}, saving...")
+                    exchange_rate = ExchangeRate.objects.create(
+                        currency_from=currency_from,
+                        currency_to=currency_to,
+                        year=year,
+                        rate=floatformat(rate, 2),
+                    )
+                else:
+                    logger.info("[convert_prices]: Could not get an exchange rate.")
+            except requests.RequestException as e:
+                logger.info(
+                    f"[convert_prices]: Failed to fetch exchange rate for {currency_from}->{currency_to} in {year}: {e}"
+                )
+        if exchange_rate:
+            save_converted_info(
+                purchase,
+                floatformat(purchase.price * exchange_rate.rate, 0),
+                currency_to,
+            )
+
+
+def calculate_price_per_game():
+    try:
+        last_task = Task.objects.filter(group="Update price per game").first()
+        last_run = last_task.started
+    except Task.DoesNotExist or AttributeError:
+        last_run = now()
+    purchases = Purchase.objects.filter(converted_price__isnull=False).filter(
+        Q(updated_at__gte=last_run) | Q(price_per_game__isnull=True)
+    )
+    logger.info(f"[calculate_price_per_game]: Updating {purchases.count()} purchases.")
+    purchases.update(
+        price_per_game=ExpressionWrapper(
+            F("converted_price") / F("num_purchases"), output_field=FloatField()
+        )
+    )

games/templates/add.html

@@ -1,13 +1,2 @@
-{% extends "base.html" %}
-
-{% block title %}{{ title }}{% endblock title %}
-
-{% block content %}
-    <form method="post" enctype="multipart/form-data" class="mx-auto">
-        {% csrf_token %}
-
-        {{ form.as_p }}
-
-        <input type="submit" value="Submit"/>
-    </form>
-{% endblock content %}
+<c-layouts.add>
+</c-layouts.add>

games/templates/add_game.html

@@ -0,0 +1,7 @@
+<c-layouts.add>
+<c-slot name="additional_row">
+    <input type="submit"
+                        name="submit_and_redirect"
+                        value="Submit & Create Purchase" />
+</c-slot>
+</c-layouts.add>

games/templates/add_purchase.html

@@ -0,0 +1,12 @@
+<c-layouts.add>
+<c-slot name="additional_row">
+<tr>
+    <td></td>
+    <td>
+        <input type="submit"
+               name="submit_and_redirect"
+               value="Submit & Create Session" />
+    </td>
+</tr>
+</c-slot>
+</c-layouts.add>

games/templates/add_session.html

@@ -0,0 +1,36 @@
+<c-layouts.add>
+<c-slot name="form_content">
+<form method="post" enctype="multipart/form-data">
+    <table class="mx-auto">
+        {% csrf_token %}
+        {% for field in form %}
+            <tr>
+                <th>{{ field.label_tag }}</th>
+                {% if field.name == "note" %}
+                    <td>{{ field }}</td>
+                {% else %}
+                    <td>{{ field }}</td>
+                {% endif %}
+                {% if field.name == "timestamp_start" or field.name == "timestamp_end" %}
+                    <td>
+                        <div class="basic-button-container" hx-boost="false">
+                            <button class="basic-button" data-target="{{ field.name }}" data-type="now">Set to now</button>
+                            <button class="basic-button"
+                                    data-target="{{ field.name }}"
+                                    data-type="toggle">Toggle text</button>
+                            <button class="basic-button" data-target="{{ field.name }}" data-type="copy">Copy</button>
+                        </div>
+                    </td>
+                {% endif %}
+            </tr>
+        {% endfor %}
+        <tr>
+            <td></td>
+            <td>
+                <input type="submit" value="Submit" />
+            </td>
+        </tr>
+    </table>
+</form>
+</c-slot>
+</c-layouts.add>

games/templates/base.html

@@ -1,51 +0,0 @@
-<!doctype html>
-<html lang="en">
-
-    {% load static %}
-
-    <head>
-        <meta charset="utf-8"/>
-        <meta name="description" content="Self-hosted time-tracker."/>
-        <meta name="keywords" content="time, tracking, video games, self-hosted"/>
-        <meta name="viewport" content="width=device-width, initial-scale=1"/>
-        <title>Timetracker - {% block title %}Untitled{% endblock title %}</title>
-        <link rel="stylesheet" href="https://rsms.me/inter/inter.css"/>
-        <link rel="stylesheet" href="{% static 'base.css' %}" />
-    </head>
-
-    <body class="dark">
-        <div class="dark:bg-gray-800 min-h-screen">
-            <nav class="mb-4 bg-white dark:bg-gray-900 border-gray-200 rounded">
-                <div class="container flex flex-wrap items-center justify-between mx-auto">
-                    <a href="{% url 'list_sessions_recent' %}" class="flex items-center">
-                        <span class="text-4xl">⌚</span>
-                        <span class="self-center text-xl font-semibold whitespace-nowrap text-white">Timetracker</span>
-                    </a>
-                    <div class="w-full md:block md:w-auto">
-                        <ul
-                            class="flex flex-col md:flex-row p-4 mt-4 dark:text-white">
-                            <li><a class="block py-2 pl-3 pr-4 hover:underline" href="{% url 'add_game' %}">New Game</a></li>
-                            <li><a class="block py-2 pl-3 pr-4 hover:underline" href="{% url 'add_platform' %}">New Platform</a></li>
-                            {% if game_available and platform_available %}
-                                <li><a class="block py-2 pl-3 pr-4 hover:underline" href="{% url 'add_edition' %}">New Edition</a></li>
-                            {% endif %}
-                            {% if edition_available %}
-                                <li><a class="block py-2 pl-3 pr-4 hover:underline" href="{% url 'add_purchase' %}">New Purchase</a></li>
-                            {% endif %}
-                            {% if purchase_available %}
-                                <li><a class="block py-2 pl-3 pr-4 hover:underline" href="{% url 'add_session' %}">New Session</a></li>
-                            {% endif %}
-                            {% if session_count > 0 %}
-                                <li><a class="block py-2 pl-3 pr-4 hover:underline" href="{% url 'list_sessions' %}">All Sessions</a></li>
-                            {% endif %}
-                        </ul>
-                    </div>
-                </div>
-            </nav>
-            {% block content %}No content here.{% endblock content %}
-        </div>
-        {% load version %}
-        <span class="fixed left-2 bottom-2 text-xs text-slate-300 dark:text-slate-600">{% version %} ({% version_date %})</span>
-    </body>
-
-</html>

games/templates/cotton/button.html

@@ -0,0 +1,6 @@
+<c-vars color="blue" size="base" type="button" />
+<button type="{{ type }}" 
+        title="{{ title }}"
+        class="{{ class }} {% if color == "blue" %} bg-blue-700 dark:bg-blue-600 dark:focus:ring-blue-800 dark:hover:bg-blue-700 focus:ring-blue-300 hover:bg-blue-800 text-white {% elif color == "red" %} bg-red-700 dark:bg-red-600 dark:focus:ring-red-900 dark:hover:bg-red-700 focus:ring-red-300 hover:bg-red-800 text-white {% elif color == "gray" %} bg-white border-gray-200 dark:bg-gray-800 dark:border-gray-600 dark:focus:ring-gray-700 dark:hover:bg-gray-700 dark:hover:text-white dark:text-gray-400 focus:ring-gray-100 hover:bg-gray-100 hover:text-blue-700 text-gray-900 border {% elif color == "green" %} bg-green-700 dark:bg-green-600 dark:focus:ring-green-800 dark:hover:bg-green-700 focus:ring-green-300 hover:bg-green-800 text-white {% endif %} focus:outline-none focus:ring-4 font-medium mb-2 me-2 rounded-lg {% if size == "xs" %} px-3 py-2 text-xs {% elif size == "sm" %} px-3 py-2 text-sm {% elif size == "base" %} px-5 py-2.5 text-sm {% elif size == "lg" %} px-5 py-3 text-base {% elif size == "xl" %} px-6 py-3.5 text-base {% endif %} {% if icon %} inline-flex text-center items-center gap-2 {% else %} {% endif %} ">
+    {{ slot }}
+</button>

games/templates/cotton/button_group.html

@@ -0,0 +1,8 @@
+<div class="inline-flex rounded-md shadow-sm" role="group">
+    {% if slot %}{{ slot }}{% endif %}
+    {% for button in buttons %}
+        {% if button.slot %}
+            <c-button-group-button-sm :href=button.href :slot=button.slot :color=button.color :hover=button.hover :title=button.title />
+        {% endif %}
+    {% endfor %}
+</div>

games/templates/cotton/button_group_button_sm.html

@@ -0,0 +1,23 @@
+<c-vars color="gray" />
+<a href="{{ href }}"
+   class="[&:first-of-type_button]:rounded-s-lg [&:last-of-type_button]:rounded-e-lg">
+    {% if color == "gray" %}
+        <button type="button"
+                title="{{ title }}"
+                class="px-2 py-1 text-xs font-medium text-gray-900 bg-white border border-gray-200 hover:bg-gray-100 hover:text-blue-700 focus:z-10 focus:ring-2 focus:ring-blue-700 focus:text-blue-700 dark:bg-gray-800 dark:border-gray-700 dark:text-white dark:hover:text-white dark:hover:bg-gray-700 dark:focus:ring-blue-500 dark:focus:text-white">
+            {{ slot }}
+        </button>
+    {% elif color == "red" %}
+        <button type="button"
+                title="{{ title }}"
+                class="px-2 py-1 text-xs font-medium text-gray-900 bg-white border border-gray-200 hover:bg-red-500 hover:text-white focus:z-10 focus:ring-2 focus:ring-blue-700 focus:text-blue-700 dark:bg-gray-800 dark:border-gray-700 dark:text-white dark:hover:text-white dark:hover:border-red-700 dark:hover:bg-red-700 dark:focus:ring-blue-500 dark:focus:text-white">
+            {{ slot }}
+        </button>
+    {% elif color == "green" %}
+        <button type="button"
+                title="{{ title }}"
+                class="px-2 py-1 text-xs font-medium text-gray-900 bg-white border border-gray-200 hover:bg-green-500 hover:border-green-600 hover:text-white focus:z-10 focus:ring-2 focus:ring-green-700 focus:text-blue-700 dark:bg-gray-800 dark:border-gray-700 dark:text-white dark:hover:text-white dark:hover:border-green-700 dark:hover:bg-green-600 dark:focus:ring-green-500 dark:focus:text-white">
+            {{ slot }}
+        </button>
+    {% endif %}
+</a>

games/templates/cotton/button_old.html

@@ -0,0 +1,13 @@
+{% comment %}
+title
+text
+{% endcomment %}
+<a href="{{ link }}"
+   title="{{ title }}"
+   class="truncate max-w-xs py-1 px-2 text-xs bg-green-600 hover:bg-green-700 focus:ring-green-500 focus:ring-offset-blue-200 text-white transition ease-in duration-200 text-center font-semibold shadow-md focus:outline-none focus:ring-2 focus:ring-offset-2 rounded-sm">
+    {% comment %} <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke-width="1.5" stroke="currentColor" class="self-center w-6 h-6 inline">
+    <path stroke-linecap="round" stroke-linejoin="round" d="M5.25 5.653c0-.856.917-1.398 1.667-.986l11.54 6.348a1.125 1.125 0 010 1.971l-11.54 6.347a1.125 1.125 0 01-1.667-.985V5.653z" /> 
+    </svg>
+    {% endcomment %}
+    {{ text }}
+</a>

games/templates/cotton/button_start.html

@@ -0,0 +1,18 @@
+{% comment %}
+title
+text
+{% endcomment %}
+<button type="button"
+        title="{{ title }}"
+        autofocus
+        class="truncate max-w-xs sm:max-w-md lg:max-w-lg py-1 px-2 bg-green-600 hover:bg-green-700 focus:ring-green-500 focus:ring-offset-blue-200 text-white transition ease-in duration-200 text-center text-base font-semibold shadow-md focus:outline-none focus:ring-2 focus:ring-offset-2 rounded-lg">
+    <svg xmlns="http://www.w3.org/2000/svg"
+         fill="none"
+         viewBox="0 0 24 24"
+         stroke-width="1.5"
+         stroke="currentColor"
+         class="self-center w-6 h-6 inline">
+        <path stroke-linecap="round" stroke-linejoin="round" d="M5.25 5.653c0-.856.917-1.398 1.667-.986l11.54 6.348a1.125 1.125 0 010 1.971l-11.54 6.347a1.125 1.125 0 01-1.667-.985V5.653z" />
+    </svg>
+    {{ text }}
+</button>