Improve make dev-prod

Replace fragile price change detection in Purchase.save() with a
lazy dirty flag approach. A pre_save/post_save signal pair detects
price/currency changes without extra DB queries, and convert_prices()
uses the flag to determine which purchases need conversion.

- Add needs_price_update BooleanField with db_index
- Add pre_save signal to store old price/currency values
- Add post_save signal to set needs_price_update=True when price/currency changes
- Simplify Purchase.save() to remove DB reload + comparison logic
- Remove price_or_currency_differ_from() method
- Update convert_prices() to filter on needs_price_update flag
- Extract _get_exchange_rate() and _save_converted_price() helpers
- Add tests for the new behavior

.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",
+}

.drone.yml

@@ -30,7 +30,9 @@ steps:
   image: plugins/docker
   settings:
     repo: registry.kucharczyk.xyz/timetracker
-    auto_tag: true
+    tags:
+      - ${DRONE_COMMIT_REF}
+      - ${DRONE_COMMIT_BRANCH}
   when:
     branch:
       exclude:

.editorconfig

@@ -15,3 +15,6 @@ indent_size = 4
 [**/*.js]
 indent_style = space
 indent_size = 2
+
+[*.html]
+insert_final_newline = false

.envrc

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

.gitea/workflows/build-docker.yml

@@ -1,25 +0,0 @@
-name: Django CI/CD
-
-on:
-  push:
-    branches: [ main ]
-    paths-ignore: [ 'README.md' ]
-
-jobs:
-  build-and-push:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-    - name: Set up Docker Buildx
-      uses: docker/setup-buildx-action@v3
-    - name: Build and push
-      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

.github/workflows/build-docker.yml

@@ -0,0 +1,50 @@
+name: Django CI/CD
+
+on:
+  push:
+    paths-ignore: [ 'README.md' ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: false
+          python-version: "3.14"
+
+      - name: Install dependencies
+        run: uv sync --frozen
+
+      - name: Run Migrations
+        run: uv run python manage.py migrate
+
+      # - name: Run Tests
+      #   run: PROD=1 uv run pytest
+
+  build-and-push:
+    needs: test
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set Version
+        run: echo "VERSION_NUMBER=1.6.1" >> $GITHUB_ENV
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          push: true
+          tags: |
+            registry.kucharczyk.xyz/timetracker:latest
+            registry.kucharczyk.xyz/timetracker:${{ env.VERSION_NUMBER }}
+          # cache-from: type=gha
+          # cache-to: type=gha,mode=max

.gitignore

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

.pre-commit-config.yaml

@@ -1,10 +0,0 @@
-repos:
--   repo: https://github.com/psf/black
-    rev: 22.12.0
-    hooks:
-    -   id: black
-- repo: https://github.com/pycqa/isort
-  rev: 5.12.0
-  hooks:
-    - id: isort
-      name: isort (python)

.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,8 +4,30 @@
     ],
     "python.testing.unittestEnabled": false,
     "python.testing.pytestEnabled": true,
-    "python.analysis.typeCheckingMode": "basic",
+    "python.analysis.typeCheckingMode": "strict",
     "[python]": {
-        "editor.defaultFormatter": "ms-python.black-formatter"
+        "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,64 @@
 ## Unreleased
 
+### Improved
+* Add a prompt to set game to Abandoned upon refund
+
+## 1.6.1 / 2026-01-30 11:48+01:00
+
+### New
+* Pre-fill time played into new playevent, also tracks time since last playevent
+* Improve light theme and fix light/dark theme switcher
+* Fix purchase form logic
+* Update dependencies
+
+## 1.6.0 / 2025-01-15 23:13+01:00
+
+### New
+* Visual overhaul of many pages
+* 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:
@@ -8,6 +67,9 @@
   * Season Pass
   * Battle Pass
 
+## Fixed
+* Order purchases by date on game view
+
 ## 1.4.0 / 2023-11-09 21:01+01:00
 
 ### New
@@ -95,22 +157,24 @@
 
 ### Enhancements
 * Improve form appearance
-* Add helper buttons next to datime fields
-* Change recent session view to current year instead of last 30 days
-* Fix bug when filtering only manual sessions (https://git.kucharczyk.xyz/lukas/timetracker/issues/51)
-* Add copy button on Add session page to copy times between fields
-* Use the same form when editing a session as when adding a session
-* Add a hacky way not to reload a page when starting or ending a session (https://git.kucharczyk.xyz/lukas/timetracker/issues/52)
 * 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)
-* Change fonts to IBM Plex
+
-* Only use local WOFF2 font files
+### 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
-* Add icons for the above
+* Allow editing filtered entities from session list
 
 ## 1.0.2 / 2023-02-18 21:48+01:00
 

Dockerfile

@@ -1,45 +1,41 @@
-FROM python:3.12.0-slim-bullseye
+FROM ghcr.io/astral-sh/uv:python3.14-bookworm-slim AS builder
 
-ENV VERSION_NUMBER=1.5.1 \
+ENV UV_LINK_MODE=copy \
-    PROD=1 \
+    UV_COMPILE_BYTECODE=1 \
+    PYTHONUNBUFFERED=1
+
+WORKDIR /home/timetracker/app
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    uv sync --frozen --no-install-project --no-dev
+
+COPY . .
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv sync --frozen --no-dev
+
+
+FROM python:3.14-slim-bookworm
+
+ENV PROD=1 \
     PYTHONUNBUFFERED=1 \
-    PYTHONFAULTHANDLER=1 \
+    PATH="/home/timetracker/app/.venv/bin:$PATH"
-    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'
-
-RUN apt-get update && apt-get upgrade -y \
-  && apt-get install --no-install-recommends -y \
-    bash \
-    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 \
-    && mkdir -p '/var/www/django/static' \
+    && mkdir -p /var/www/django/static \
-    && chown timetracker:timetracker '/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 entrypoint.sh /
-RUN chmod +x /entrypoint.sh
 
-RUN --mount=type=cache,target="$POETRY_CACHE_DIR" \
+COPY --from=builder --chown=timetracker:timetracker /home/timetracker/app /home/timetracker/app
-    echo "$PROD" \
+
-    && poetry version \
+COPY --chown=timetracker:timetracker entrypoint.sh /
-    && poetry run pip install -U pip \
+RUN chmod +x /entrypoint.sh
-    && poetry install --only main --no-interaction --no-ansi --sync
 
 USER timetracker
 
+ENV VERSION_NUMBER=1.6.1
+
 EXPOSE 8000
 CMD [ "/entrypoint.sh" ]

Makefile

@@ -1,56 +1,79 @@
-all: migrate
+all: css migrate
 
-initialize: npm migrate sethookdir loadplatforms
+initialize: npm css migrate sethookdir loadplatforms
 
 HTMLFILES := $(shell find games/templates -type f)
+PYTHON_VERSION = 3.12
 
 npm:
 	npm install
 
+css: common/input.css
+	npx @tailwindcss/cli -i ./common/input.css -o  ./games/static/base.css
+
 makemigrations:
-	poetry run python manage.py makemigrations
+	uv run python manage.py makemigrations
 
 migrate: makemigrations
-	poetry run python manage.py migrate
+	uv run python manage.py migrate
+
+init:
+	uv install $(PYTHON_VERSION)
+	uv sync
+	npm install
+	$(MAKE) sethookdir
+	$(MAKE) loadplatforms
+
+sethookdir:
+	git config core.hooksPath .githooks
+	chmod +x .githooks/*
+
+dev:
+	@npx concurrently \
+		--names "Django,Tailwind" \
+		--prefix-colors "blue,green" \
+		"uv run python -Wa manage.py runserver" \
+		"npx @tailwindcss/cli -i ./common/input.css -o ./games/static/base.css --watch"
 
-dev: migrate
-	poetry run python manage.py runserver
 
 caddy:
 	caddy run --watch
 
 dev-prod: migrate collectstatic
-	PROD=1 poetry run python -m gunicorn --bind 0.0.0.0:8001 timetracker.asgi:application -k uvicorn.workers.UvicornWorker
+	@npx concurrently \
+	--names "Django,Django-Q" \
+	"PROD=1 uv run python -m gunicorn --bind 0.0.0.0:8001 timetracker.asgi:application -k uvicorn.workers.UvicornWorker"
+	"uv run manage.py qcluster"
 
 dumpgames:
-	poetry run python manage.py dumpdata --format yaml games --output tracker_fixture.yaml
+	uv run python manage.py dumpdata --format yaml games --output tracker_fixture.yaml
 
 loadplatforms:
-	poetry run python manage.py loaddata platforms.yaml
+	uv run python manage.py loaddata platforms.yaml
 
 loadall:
-	poetry run python manage.py loaddata data.yaml
+	uv run python manage.py loaddata data.yaml
 
 loadsample:
-	poetry run python manage.py loaddata sample.yaml
+	uv run python manage.py loaddata sample.yaml
 
 createsuperuser:
-	poetry run python manage.py createsuperuser
+	uv run python manage.py createsuperuser
 
 shell:
-	poetry run python manage.py shell
+	uv run python manage.py shell
 
 collectstatic:
-	poetry run python manage.py collectstatic --clear --no-input
+	uv run python manage.py collectstatic --clear --no-input
 
-poetry.lock: pyproject.toml
+uv.lock: pyproject.toml
-	poetry install
+	uv sync
 
-test: poetry.lock
+test: uv.lock
-	poetry run pytest
+	uv run --with pytest-django pytest
 
 date:
-	poetry run python -c 'import datetime; from zoneinfo import ZoneInfo; print(datetime.datetime.isoformat(datetime.datetime.now(ZoneInfo("Europe/Prague")), timespec="minutes", sep=" "))'
+	uv run python -c 'import datetime; from zoneinfo import ZoneInfo; print(datetime.datetime.isoformat(datetime.datetime.now(ZoneInfo("Europe/Prague")), timespec="minutes", sep=" "))'
 
 cleanstatic:
 	rm -r static/*

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`.

STATUSES.md

@@ -0,0 +1,157 @@
+# Game & Purchase Status Definitions
+
+## Game Statuses
+
+Games have a `status` field with the following values:
+
+| Status | Code | Description |
+|--------|------|-------------|
+| **Unplayed** | `u` | Game was purchased but never played |
+| **Played** | `p` | Game was played but not yet finished |
+| **Finished** | `f` | Game has been completed |
+| **Retired** | `r` | Game was intentionally retired (e.g., no longer accessible, collector's item) |
+| **Abandoned** | `a` | Game was played but the user gave up on it |
+
+**Setting game status:**
+- Users explicitly set game status via the UI (finish/drop purchase buttons, status change form)
+- Status changes are tracked in `GameStatusChange` model
+- Refunding a purchase always marks its games as abandoned
+
+---
+
+## Purchase-Level Status Concepts
+
+These concepts determine whether a purchase appears in the "unfinished" or "dropped" lists in stats views.
+
+### Finished
+
+A purchase is considered **finished** when:
+
+```
+Game.status == "f" OR Purchase.games.* has a PlayEvent with an ended date
+```
+
+Either signal indicates the game is complete:
+- **Explicit**: User marked the game as finished (`Game.status = "f"`)
+- **Implicit**: A PlayEvent exists with `ended` date set (data-driven)
+
+This uses **OR** logic during a transition period. Later, these signals should be kept in sync so only one source of truth is needed.
+
+### Dropped
+
+A purchase is considered **dropped** when:
+
+```
+Game.status == "a" OR Purchase.date_refunded IS NOT NULL
+```
+
+Either signal indicates the user no longer has an active interest in the game:
+- **Explicit**: User marked the game as abandoned (`Game.status = "a"`)
+- **Implicit**: User refunded the purchase (which automatically sets games to abandoned)
+
+Note: Refunding a purchase always marks its games as abandoned. There is no option to refund without abandoning.
+
+---
+
+## Unfinished vs. Dropped
+
+The stats views categorize purchases into **unfinished** and **dropped** lists.
+
+### Unfinished
+
+A purchase is **unfinished** when:
+1. It was purchased in the relevant time period (this year for yearly stats, all time for all-time stats)
+2. It was NOT refunded (only counts toward unfinished/backlog)
+3. It is NOT finished (per the finished definition above)
+4. It is NOT dropped (per the dropped definition above)
+5. It is NOT infinite (subscription, etc.)
+6. It IS a game or DLC (not season passes or battle passes)
+
+**Unfinished = Active backlog** — games the user may still play.
+
+### Dropped
+
+A purchase is **dropped** when:
+1. It was purchased in the relevant time period
+2. It is NOT finished (per the finished definition above)
+3. It matches at least one dropped signal (per the dropped definition above)
+4. It is NOT infinite
+5. It IS a game or DLC
+
+**Dropped = Terminal state** — games the user has given up on or refunded.
+
+### Summary Table
+
+| Category | Includes Refunded? | Key Condition |
+|----------|-------------------|---------------|
+| **Unfinished** | No | NOT finished, NOT dropped |
+| **Dropped** | Yes | Finished OR Abandoned/Retired |
+| **Refunded** | Yes | `date_refunded IS NOT NULL` |
+| **Infinite** | Yes | `infinite = True` |
+
+---
+
+## Query Patterns
+
+### Checking if a game is finished
+
+```python
+game.finished()  # Returns True if status="f" or has PlayEvent with ended date
+```
+
+### Checking if a game is abandoned
+
+```python
+game.abandoned()  # Returns True if status="a"
+```
+
+### Getting finished purchases
+
+```python
+Purchase.objects.finished()  # All purchases where games are finished
+```
+
+### Getting dropped purchases
+
+```python
+Purchase.objects.dropped()  # All purchases that are abandoned or refunded
+```
+
+---
+
+## Transition State
+
+The system uses **OR logic** for both finished and dropped to catch any mismatch between explicit user actions and data signals:
+
+- **Finished**: `status="f" OR PlayEvent.ended`
+- **Dropped**: `status="a" OR date_refunded`
+
+This bridges the gap between the old model (where `date_finished` and `date_dropped` were on the Purchase model) and the new model (where `Game.status` and `PlayEvent` are the sources of truth).
+
+**Future:** These signals should be kept in sync. For example:
+- Setting `Game.status = "f"` should create a PlayEvent with `ended` date
+- When the sync is reliable, the OR can be simplified to a single check
+
+Note: Refunding a purchase always automatically sets its games' status to Abandoned. This is not optional — there is no way to refund without abandoning.
+
+---
+
+## Edge Cases
+
+### Unplayed games
+- Unplayed games (`status="u"`) are considered **unfinished**, not dropped
+- They appear in the unfinished/backlog list since they are still games the user may play
+- Unplayed games that are refunded DO count as **dropped** (refund signal overrides)
+
+### Multiple games per purchase
+- A purchase can have multiple games via `Purchase.games` (many-to-many)
+- A purchase is finished if ANY of its games is finished
+- A purchase is dropped if ANY of its games is abandoned OR the purchase itself is refunded
+
+### PlayEvents without ended date
+- A PlayEvent with `started` but no `ended` does NOT count as finished
+- This represents a game that was started but not completed
+
+### Retired games
+- Retired games (`status="r"`) are considered **dropped**
+- Retirement is for games the user intentionally removed from their collection (collector's items, no longer accessible, etc.)

common/COMPONENT_IMPROVEMENTS.md

@@ -0,0 +1,46 @@
+# Suggested Improvements to common/components.py
+
+## Completed
+
+### Caching on template rendering
+- Added `functools.lru_cache` on `_render_cached()` wrapper around `render_to_string`
+- Cache key: `(template_path, json.dumps(context, sort_keys=True))` — deterministic and unique
+- `maxsize=4096` in production, disabled entirely in DEBUG mode (so template changes are reflected immediately)
+- Only caches `template` path calls; `tag_name` calls are already nanosecond string ops
+- Verified working: identical calls return identical output, different inputs produce separate cache entries
+
+### Non-deterministic IDs
+`randomid()` was replaced with `hashlib.sha1(content_hash.encode()).hexdigest()[:10]` for deterministic ID generation.
+- `Popover()` passes content hash (`wrapped_content:popover_content:wrapped_classes`) so IDs are deterministic per unique content
+- `games/templatetags/randomid.py` uses the same hash-based approach
+- Fixes: caching (Popover output now cacheable), page consistency, thread safety
+
+### Inconsistent return types
+All component functions now return `SafeText` and are annotated accordingly. Redundant `mark_safe()` wrappers removed from `LinkedPurchase()` and `NameWithIcon()`.
+
+### Fragile A() URL resolution
+Replaced single `url` parameter with explicit `url_name` (URL pattern name resolved via `reverse()`) and `href` (literal path). Removed dead `Callable` type hint. `reverse()` now raises `NoReverseMatch` instead of silently falling back to literal text. Added mutual exclusion check — providing both parameters raises `ValueError`. Updated all 10 call sites across 6 view files and internal callers (`LinkedPurchase()`, `NameWithIcon()`).
+
+### Toast XSS vulnerability
+The vulnerable `Toast()` component (which used unsafe string escaping for
+Alpine.js interpolation) had no callers and was deleted entirely. Toast display
+is handled by the existing event-driven pipeline: middleware → `HX-Trigger`
+headers → `show-toast` CustomEvent → Alpine store.
+
+### Default mutable arguments
+All functions with mutable defaults (`attributes` and `children`) changed from `= []` to `| None = None` with `or []` conversion in the body.
+
+What was fixed: `attributes: list[HTMLAttribute] = []` and `children: list[HTMLTag] | HTMLTag = []` are a classic Python gotcha — the default is shared across all callers and could silently corrupt state if ever mutated in place. Changed 8 functions (`Component`, `Popover`, `A`, `Button`, `Div`, `Input`, `Form`, `Icon`) to use the `None` sentinel pattern, preventing future bugs and eliminating linter warnings.
+
+### NameWithIcon dead code and untestable design
+The `NameWithIcon()` function had a `platform` parameter that was immediately overwritten by `platform = None` and never used (dead code). The function mixed data lookup (database queries via IDs) with rendering, making it untestable.
+
+**Fix**: Refactored `NameWithIcon()` to follow the `LinkedPurchase` pattern — accepts model objects (`Game`, `Session`) instead of IDs. Extracted `_resolve_name_with_icon()` helper for testable computation logic (name resolution, platform extraction, link creation). Fixed bug where `platform` was not extracted when `session` parameter was passed. Removed dead `platform` parameter from the public API. Updated all 3 production call sites (already using model objects). Added 10 unit tests for `_resolve_name_with_icon()` covering session override, custom names, linkify behavior, platform resolution, and edge cases. Updated 6 integration tests to use model-based parameters.
+
+### No tests
+Zero test coverage for the entire component system.
+
+**Fix**: Add unit tests for each component function — basic rendering, edge cases,
+and cache hit/miss verification.
+
+**Done**: 96 unit tests covering all component functions (`Component`, `randomid`, `Popover`, `PopoverTruncated`, `A`, `Button`, `Div`, `Icon`, `Form`, `Input`, `NameWithIcon`, `LinkedPurchase`, `PurchasePrice`, `_render_cached`, `enable_cache`). Includes template rendering, deterministic ID generation, LRU cache behavior, HTML output validation, edge cases, error handling, and model-dependent integration tests.

common/components.py

@@ -0,0 +1,344 @@
+import hashlib
+import json
+from functools import lru_cache
+from typing import Any
+
+from django.conf import settings
+from django.template import TemplateDoesNotExist
+from django.template.defaultfilters import floatformat
+from django.template.loader import render_to_string
+from django.urls import 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 _render_cached_impl(template: str, context_json: str) -> str:
+    context = json.loads(context_json)
+    context["slot"] = mark_safe(context["slot"])
+    return render_to_string(template, context)
+
+
+if not settings.DEBUG:
+    _render_cached = lru_cache(maxsize=4096)(_render_cached_impl)
+else:
+    _render_cached = _render_cached_impl
+
+
+def enable_cache():
+    """Wrap _render_cached with LRU cache (for testing in DEBUG mode)."""
+    global _render_cached
+    _render_cached = lru_cache(maxsize=4096)(_render_cached_impl)
+
+
+def Component(
+    attributes: list[HTMLAttribute] | None = None,
+    children: list[HTMLTag] | HTMLTag | None = None,
+    template: str = "",
+    tag_name: str = "",
+) -> SafeText:
+    attributes = attributes or []
+    children = children or []
+    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 != "":
+        context = {name: value for name, value in attributes} | {"slot": "\n".join(children)}
+        tag = _render_cached(template, json.dumps(context, sort_keys=True))
+    return mark_safe(tag)
+
+
+def randomid(seed: str = "", content: str = "", length: int = 10) -> str:
+    if not seed and not content:
+        return seed
+    hash_input = f"{seed}:{content}" if seed else content
+    content_hash = hashlib.sha1(hash_input.encode()).hexdigest()
+    base = content_hash[:length] if not seed else content_hash[:max(0, length - len(seed))]
+    return seed + base
+
+
+def Popover(
+    popover_content: str,
+    wrapped_content: str = "",
+    wrapped_classes: str = "",
+    children: list[HTMLTag] | None = None,
+    attributes: list[HTMLAttribute] | None = None,
+) -> str:
+    attributes = attributes or []
+    children = children or []
+    if not wrapped_content and not children:
+        raise ValueError("One of wrapped_content or children is required.")
+    id = randomid(content=f"{wrapped_content}:{popover_content}:{wrapped_classes}")
+    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] | None = None,
+    children: list[HTMLTag] | HTMLTag | None = None,
+    url_name: str | None = None,
+    href: str | None = None,
+) -> SafeText:
+    """
+    Returns an anchor <a> tag.
+
+    Accepts one of two mutually-exclusive URL specifications:
+        - url_name: URL pattern name, resolved via reverse()
+        - href: Literal path string passed through as-is
+    """
+    attributes = attributes or []
+    children = children or []
+    if url_name is not None and href is not None:
+        raise ValueError("Provide exactly one of 'url_name' or 'href', not both.")
+
+    additional_attributes = []
+    if url_name is not None:
+        additional_attributes = [("href", reverse(url_name))]
+    elif href is not None:
+        additional_attributes = [("href", href)]
+    return Component(
+        tag_name="a", attributes=attributes + additional_attributes, children=children
+    )
+
+
+def Button(
+    attributes: list[HTMLAttribute] | None = None,
+    children: list[HTMLTag] | HTMLTag | None = None,
+    size: str = "base",
+    icon: bool = False,
+    color: str = "blue",
+) -> SafeText:
+    attributes = attributes or []
+    children = children or []
+    return Component(
+        template="cotton/button.html",
+        attributes=attributes
+        + [
+            ("size", size),
+            ("icon", icon),
+            ("color", color),
+            ("class", "hover:cursor-pointer"),
+        ],
+        children=children,
+    )
+
+
+def Div(
+    attributes: list[HTMLAttribute] | None = None,
+    children: list[HTMLTag] | HTMLTag | None = None,
+) -> SafeText:
+    attributes = attributes or []
+    children = children or []
+    return Component(tag_name="div", attributes=attributes, children=children)
+
+
+def Input(
+    type: str = "text",
+    attributes: list[HTMLAttribute] | None = None,
+    children: list[HTMLTag] | HTMLTag | None = None,
+) -> SafeText:
+    attributes = attributes or []
+    children = children or []
+    return Component(
+        tag_name="input", attributes=attributes + [("type", type)], children=children
+    )
+
+
+def Form(
+    action="",
+    method="get",
+    attributes: list[HTMLAttribute] | None = None,
+    children: list[HTMLTag] | HTMLTag | None = None,
+) -> SafeText:
+    attributes = attributes or []
+    children = children or []
+    return Component(
+        tag_name="form",
+        attributes=attributes + [("action", action), ("method", method)],
+        children=children,
+    )
+
+
+def Icon(
+    name: str,
+    attributes: list[HTMLAttribute] | None = None,
+) -> SafeText:
+    attributes = attributes or []
+    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("games: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 A(href=link, children=[a_content])
+
+
+def NameWithIcon(
+    name: str = "",
+    game: Game | None = None,
+    session: Session | None = None,
+    linkify: bool = True,
+    emulated: bool = False,
+) -> SafeText:
+    _name, platform, final_emulated, create_link, link = _resolve_name_with_icon(
+        name, game, session, linkify
+    )
+
+    content = Div(
+        [("class", "inline-flex gap-2 items-center")],
+        [
+            Icon(
+                platform.icon,
+                [("title", platform.name)],
+            )
+            if platform
+            else "",
+            Icon("emulated", [("title", "Emulated")]) if final_emulated else "",
+            PopoverTruncated(_name),
+        ],
+    )
+
+    return (
+        A(
+            href=link,
+            children=[content],
+        )
+        if create_link
+        else content
+    )
+
+
+def _resolve_name_with_icon(
+    name: str,
+    game: Game | None,
+    session: Session | None,
+    linkify: bool,
+) -> tuple[str, Any, bool, bool, str]:
+    create_link = False
+    link = ""
+    platform = None
+    final_emulated = False
+
+    if session is not None:
+        game = session.game
+        platform = game.platform
+        final_emulated = session.emulated
+        if linkify:
+            create_link = True
+            link = reverse("games:view_game", args=[int(game.pk)])
+    elif game is not None:
+        platform = game.platform
+        if linkify:
+            create_link = True
+            link = reverse("games:view_game", args=[int(game.pk)])
+
+    _name = name or (game.name if game else "")
+
+    return _name, platform, final_emulated, create_link, link
+
+
+def PurchasePrice(purchase) -> SafeText:
+    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

@@ -0,0 +1,233 @@
+@import 'tailwindcss';
+
+@plugin '@tailwindcss/typography';
+@plugin '@tailwindcss/forms';
+@plugin 'flowbite/plugin';
+
+@source "../node_modules/flowbite";
+@import "flowbite/src/themes/default";
+
+@custom-variant dark (&:is(.dark *));
+
+@theme {
+  --font-sans:
+    IBM Plex Sans, ui-sans-serif, system-ui, sans-serif, 'Apple Color Emoji',
+    'Segoe UI Emoji', 'Segoe UI Symbol', 'Noto Color Emoji';
+  --font-mono:
+    IBM Plex Mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas,
+    'Liberation Mono', 'Courier New', monospace;
+  --font-serif:
+    IBM Plex Serif, ui-serif, Georgia, Cambria, 'Times New Roman', Times, serif;
+  --font-condensed:
+    IBM Plex Sans Condensed, ui-sans-serif, system-ui, sans-serif,
+    'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol', 'Noto Color Emoji';
+
+  --color-accent: #7c3aed;
+  --color-background: #1f2937;
+}
+
+
+/*
+  The default border color has changed to `currentcolor` in Tailwind CSS v4,
+  so we've added these compatibility styles to make sure everything still
+  looks the same as it did with Tailwind CSS v3.
+
+  If we ever want to remove these styles, we need to add an explicit border
+  color utility to any element that depends on these defaults.
+*/
+@layer base {
+  *,
+  ::after,
+  ::before,
+  ::backdrop,
+  ::file-selector-button {
+    border-color: var(--color-gray-200, currentcolor);
+  }
+}
+
+@utility min-w-20char {
+  min-width: 20ch;
+}
+
+@utility max-w-20char {
+  max-width: 20ch;
+}
+
+@utility min-w-30char {
+  min-width: 30ch;
+}
+
+@utility max-w-30char {
+  max-width: 30ch;
+}
+
+@utility max-w-35char {
+  max-width: 35ch;
+}
+
+@utility max-w-40char {
+  max-width: 40ch;
+}
+
+@layer utilities {
+  @font-face {
+    font-family: 'IBM Plex Mono';
+    src: url('fonts/IBMPlexMono-Regular.woff2') format('woff2');
+    font-weight: 400;
+    font-style: normal;
+  }
+
+  @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;
+  }
+
+  .responsive-table {
+    @apply dark:text-white mx-auto table-fixed;
+  }
+
+  .responsive-table tr:nth-child(even) {
+    @apply bg-indigo-100 dark:bg-slate-800;
+  }
+
+  .responsive-table tbody tr:nth-child(odd) {
+    @apply bg-indigo-200 dark: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;
+  }
+}
+
+form input:disabled,
+select:disabled,
+textarea:disabled {
+  @apply cursor-not-allowed bg-neutral-secondary-strong text-fg-disabled;
+   
+}
+
+.errorlist {
+  @apply mt-4 mb-1 pl-3 py-2 bg-red-600 text-slate-200 w-[300px];
+}
+
+#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-sm shadow-md hover:bg-blue-700 hover:shadow-lg focus:bg-blue-700 focus:shadow-lg focus:outline-hidden 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;
+}
+
+#add-form {
+  label + select, input, textarea {
+    @apply mt-1;
+  }
+  form {
+    @apply flex flex-col gap-3;
+  }
+
+  .form-row-button-group {
+    display: flex;
+    flex-direction: row;
+    @apply gap-0 p-0;
+    button {
+      @apply mr-0;
+      &:first-child {
+        @apply rounded-e-none;
+      }
+      &:nth-child(2) {
+        @apply rounded-none;
+      }
+      &:last-child {
+        @apply rounded-s-none;
+      }
+    }
+  }
+  label {
+    @apply mb-2.5 text-sm font-medium text-heading;
+  }
+  input:not([type="checkbox"]) {
+    @apply mb-3 bg-neutral-secondary-medium border border-default-medium text-heading text-sm rounded-base focus:ring-brand focus:border-brand block w-full px-3 py-2.5 shadow-xs placeholder:text-body; 
+  }
+  input[type="checkbox"] {
+    @apply  w-4 h-4 border border-default-medium rounded-xs bg-neutral-secondary-medium focus:ring-2 focus:ring-brand-soft;
+  }
+  select {
+    @apply w-full px-3 py-2.5 bg-neutral-secondary-medium border border-default-medium text-heading text-sm rounded-base focus:ring-brand focus:border-brand shadow-xs placeholder:text-body;
+  }
+  textarea {
+    @apply bg-neutral-secondary-medium border border-default-medium text-heading text-sm rounded-base focus:ring-brand focus:border-brand block w-full p-3.5 shadow-xs placeholder:text-body;
+  }
+  :has(> label + input[type="checkbox"]) {
+    @apply mt-3; /* needed because compared to all other form elements checkbox and its label are on the same row */
+    display: flex;
+    flex-direction: row;
+    justify-content: space-between;
+  }
+}
+
+@layer utilities {
+  .toast-container {
+    @apply fixed z-50 flex flex-col items-end bottom-0 right-0 p-4;
+  }
+}

common/time.py

@@ -1,9 +1,19 @@
 import re
-from datetime import timedelta
+from datetime import date, datetime, timedelta
+
+from django.utils import timezone
+
+from common.utils import generate_split_ranges
+
+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)
@@ -12,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.
@@ -70,3 +80,90 @@ def format_duration(
                 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

@@ -1,3 +1,15 @@
+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.
@@ -7,3 +19,149 @@ def safe_division(numerator: int | float, denominator: int | float) -> int | flo
         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

entrypoint.sh

@@ -2,18 +2,22 @@
 # Apply database migrations
 set -euo pipefail
 echo "Apply database migrations"
-poetry run python manage.py migrate
+python manage.py migrate
 
 echo "Collect static files"
-poetry run python manage.py collectstatic --clear --no-input
+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 app"
+echo "Starting Django-Q cluster"
-poetry run python -m gunicorn --bind 0.0.0.0:8001 timetracker.asgi:application -k uvicorn.workers.UvicornWorker --access-logfile - --error-logfile - & gunicorn_pid=$!
+python manage.py qcluster & django_q_pid=$!
 
-wait "$gunicorn_pid"
+echo "Starting app"
+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"

frontend/.eslintrc.cjs

@@ -1,17 +0,0 @@
-module.exports = {
-  env: {
-    browser: true,
-    es2021: true
-  },
-  extends: ["eslint/recommended", "plugin:react/recommended", "plugin:prettier/recommended"],
-  overrides: [],
-  parserOptions: {
-    ecmaVersion: "latest",
-    sourceType: "module"
-  },
-  plugins: ["react"],
-  rules: {},
-  parserOptions: {
-    ecmaFeatures: { jsx: true }
-  }
-};

frontend/.gitignore

@@ -1,24 +0,0 @@
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
-lerna-debug.log*
-
-node_modules
-dist
-dist-ssr
-*.local
-
-# Editor directories and files
-.vscode/*
-!.vscode/extensions.json
-.idea
-.DS_Store
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?

frontend/.prettierrc

@@ -1,9 +0,0 @@
-{
-    "semi": true,
-    "tabWidth": 2,
-    "printWidth": 100,
-    "singleQuote": true,
-    "trailingComma": "none",
-    "bracketSameLine": false,
-    "singleAttributePerLine": true
-}

frontend/index.html

@@ -1,17 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <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.0" />
-    <!-- TODO: replace with own icon -->
-    <!-- <link rel="icon" type="image/svg+xml" href="/vite.svg" /> -->
-    <link rel="stylesheet" href="https://rsms.me/inter/inter.css"/>
-    <title>Timetracker</title>
-  </head>
-  <body class="dark">
-    <div id="root"></div>
-    <script type="module" src="/src/main.jsx"></script>
-  </body>
-</html>

frontend/package.json

@@ -1,29 +0,0 @@
-{
-  "name": "frontend",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite",
-    "build": "vite build",
-    "preview": "vite preview"
-  },
-  "dependencies": {
-    "autoprefixer": "^10.4.13",
-    "postcss": "^8.4.21",
-    "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "tailwindcss": "^3.2.4"
-  },
-  "devDependencies": {
-    "@types/react": "^18.0.26",
-    "@types/react-dom": "^18.0.9",
-    "@vitejs/plugin-react": "^3.0.0",
-    "eslint": "^8.32.0",
-    "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-jsx-a11y": "^6.7.1",
-    "eslint-plugin-react": "^7.32.1",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "vite": "^4.0.0"
-  }
-}

frontend/postcss.config.cjs

@@ -1,6 +0,0 @@
-module.exports = {
-  plugins: {
-    tailwindcss: {},
-    autoprefixer: {},
-  },
-}

frontend/src/App.jsx

@@ -1,42 +0,0 @@
-import { useState } from 'react'
-import './App.css'
-
-function App() {
-  
-
-  return (
-    <>
-    <div className="dark:bg-gray-800 min-h-screen">
-            <nav className="mb-4 bg-white dark:bg-gray-900 border-gray-200 rounded">
-                <div className="container flex flex-wrap items-center justify-between mx-auto">
-                    <a href="{% url 'index' %}" className="flex items-center">
-                        <span className="text-4xl">⌚</span>
-                        <span className="self-center text-xl font-semibold whitespace-nowrap text-white">Timetracker</span>
-                    </a>
-                    <div className="w-full md:block md:w-auto">
-                        <ul
-                            className="flex flex-col md:flex-row p-4 mt-4 dark:text-white">
-                            <li><a className="block py-2 pl-3 pr-4 hover:underline" href="{% url 'add_game' %}">New Game</a></li>
-                            <li><a className="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 className="block py-2 pl-3 pr-4 hover:underline" href="{% url 'add_purchase' %}">New Purchase</a></li>
-                            {/* {% endif %} */}
-                            {/* {% if purchase_available %} */}
-                                <li><a className="block py-2 pl-3 pr-4 hover:underline" href="{% url 'add_session' %}">New Session</a></li>
-                            {/* {% endif %} */}
-                            {/* {% if session_count > 0 %} */}
-                                <li><a className="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 className="fixed left-2 bottom-2 text-xs text-slate-300 dark:text-slate-600">{% version %} ({% version_date %})</span> */}
-        </>
-  )
-}
-
-export default App;

frontend/src/components/Nav.jsx

@@ -1,71 +0,0 @@
-import { Link } from 'react-router-dom';
-
-function Nav() {
-  return (
-    <nav className="mb-4 bg-white dark:bg-gray-900 border-gray-200 rounded">
-      <div className="container flex flex-wrap items-center justify-between mx-auto">
-        <Link
-          to="/"
-          className="flex items-center"
-        >
-          <span className="text-4xl">⌚</span>
-          <span className="self-center text-xl font-semibold whitespace-nowrap text-white">
-            Timetracker
-          </span>
-        </Link>
-        <div className="w-full md:block md:w-auto">
-          <ul className="flex flex-col md:flex-row p-4 mt-4 dark:text-white">
-            <li>
-              <a
-                className="block py-2 pl-3 pr-4 hover:underline"
-                href="{% url 'add_game' %}"
-              >
-                New Game
-              </a>
-            </li>
-            <li>
-              <a
-                className="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
-                className="block py-2 pl-3 pr-4 hover:underline"
-                href="{% url 'add_purchase' %}"
-              >
-                New Purchase
-              </a>
-            </li>
-            {/* {% endif %} */}
-            {/* {% if purchase_available %} */}
-            <li>
-              <a
-                className="block py-2 pl-3 pr-4 hover:underline"
-                href="{% url 'add_session' %}"
-              >
-                New Session
-              </a>
-            </li>
-            {/* {% endif %} */}
-            {/* {% if session_count > 0 %} */}
-            <li>
-              <Link
-                className="block py-2 pl-3 pr-4 hover:underline"
-                to="/sessions"
-              >
-                All Sessions
-              </Link>
-            </li>
-            {/* {% endif %} */}
-          </ul>
-        </div>
-      </div>
-    </nav>
-  );
-}
-
-export default Nav;

frontend/src/components/SessionList.jsx

@@ -1,162 +0,0 @@
-export default function SessionList() {
-  const data = [
-    {
-        "url": "http://localhost:8000/api/sessions/25/",
-        "timestamp_start": "2020-01-01T00:00:00+01:00",
-        "timestamp_end": null,
-        "duration_manual": "12:00:00",
-        "duration_calculated": "00:00:00",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/3/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/26/",
-        "timestamp_start": "2022-12-31T15:25:00+01:00",
-        "timestamp_end": "2022-12-31T17:25:00+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "02:00:00",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/2/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/27/",
-        "timestamp_start": "2023-01-01T23:00:00+01:00",
-        "timestamp_end": "2023-01-02T00:28:00+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "01:28:00",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/3/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/28/",
-        "timestamp_start": "2023-01-02T22:08:00+01:00",
-        "timestamp_end": "2023-01-03T01:08:00+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "03:00:00",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/3/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/29/",
-        "timestamp_start": "2023-01-03T22:36:00+01:00",
-        "timestamp_end": "2023-01-04T00:12:00+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "01:36:00",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/3/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/30/",
-        "timestamp_start": "2023-01-04T20:35:00+01:00",
-        "timestamp_end": "2023-01-04T22:36:00+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "02:01:00",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/3/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/31/",
-        "timestamp_start": "2023-01-06T18:48:00+01:00",
-        "timestamp_end": "2023-01-06T23:39:00+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "04:51:00",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/3/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/32/",
-        "timestamp_start": "2023-01-07T23:49:00+01:00",
-        "timestamp_end": "2023-01-08T01:43:00+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "01:54:00",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/3/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/33/",
-        "timestamp_start": "2023-01-08T16:21:00+01:00",
-        "timestamp_end": "2023-01-08T18:27:00+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "02:06:00",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/3/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/34/",
-        "timestamp_start": "2023-01-08T19:04:00+01:00",
-        "timestamp_end": "2023-01-08T22:03:00+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "02:59:00",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/3/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/35/",
-        "timestamp_start": "2023-01-09T19:35:48+01:00",
-        "timestamp_end": "2023-01-09T22:13:20.519058+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "02:37:32.519058",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/3/"
-    },
-    {
-        "url": "http://localhost:8000/api/sessions/36/",
-        "timestamp_start": "2023-01-10T15:50:12+01:00",
-        "timestamp_end": "2023-01-10T17:03:45.424429+01:00",
-        "duration_manual": "00:00:00",
-        "duration_calculated": "01:13:33.424429",
-        "note": "",
-        "purchase": "http://localhost:8000/api/purchases/4/"
-    }
-  ]
-  const header = ["url", "timestamp_start", "timestamp_end", "duration_manual", "duration_calculated", "note", "purchase"]
-  // const header = ["Name", "Platform", "Start", "End", "Duration", "Manage"]
-  return (
-        <>
-          <div id="session-table" className="gap-4 shadow rounded-xl max-w-screen-lg mx-auto dark:bg-slate-700 p-2 justify-center">
-              {header.map(column => {
-                <div className="dark:border-white dark:text-slate-300 text-lg">{column}</div>
-              })}
-          {data.map(session => {
-              <>
-                <div className="dark:text-white overflow-hidden text-ellipsis whitespace-nowrap">
-                <a className="hover:underline" href="">
-                  { session.url }
-                </a>
-                <div className="dark:text-white overflow-hidden text-ellipsis whitespace-nowrap">
-                <a className="hover:underline" href="">
-                  { session.timestamp_start }
-                </a>
-              </div>
-              <div className="dark:text-white overflow-hidden text-ellipsis whitespace-nowrap">
-                <a className="hover:underline" href="">
-                  { session.timestamp_end }
-                </a>
-              </div>
-              <div className="dark:text-white overflow-hidden text-ellipsis whitespace-nowrap">
-                <a className="hover:underline" href="">
-                  { session.duration_manual }
-                </a>
-              </div>
-              <div className="dark:text-white overflow-hidden text-ellipsis whitespace-nowrap">
-                <a className="hover:underline" href="">
-                  { session.duration_calculated }
-                </a>
-              </div>
-              <div className="dark:text-white overflow-hidden text-ellipsis whitespace-nowrap">
-                <a className="hover:underline" href="">
-                  { session.note }
-                </a>
-              </div>
-              <div className="dark:text-white overflow-hidden text-ellipsis whitespace-nowrap">
-                <a className="hover:underline" href="">
-                  { session.purchase }
-                </a>
-              </div>
-              </div>
-              </>
-          })}
-          </div>
-        </>
-  )
-}

frontend/src/error-page.jsx

@@ -1,16 +0,0 @@
-import { useRouteError } from "react-router-dom";
-
-export default function ErrorPage() {
-    const error = useRouteError()
-    console.error(error)
-
-    return (
-        <div className="container text-center">
-            <h1 className="text-3xl">Oops!</h1>
-            <p>Sorry, an unexpected error has occurred.</p>
-            <p>
-                <i>{error.statusText || error.message}</i>
-            </p>
-        </div>
-    )
-}

frontend/src/index.css

@@ -1,22 +0,0 @@
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
-
-form label {
-  @apply dark:text-slate-400;
-}
-
-form input,
-select,
-textarea {
-  @apply dark:border dark:border-slate-900 dark:bg-slate-500 dark:text-slate-100;
-}
-
-#session-table {
-  display: grid;
-  grid-template-columns: 3fr 1fr repeat(2, 2fr) 0.5fr 1fr;
-}
-
-#button-container button {
-  @apply mx-1;
-}

frontend/src/main.jsx

@@ -1,34 +0,0 @@
-import React from 'react'
-import ReactDOM from 'react-dom/client'
-import App from './App'
-import './index.css'
-import { createBrowserRouter, RouterProvider } from 'react-router-dom'
-// import { loader as sessionLoader } from './routes/sessions'
-import ErrorPage from "./error-page"
-import SessionList from './components/SessionList'
-// import Session from './routes/sessions'
-
-const router = createBrowserRouter([
-  {
-    path: "/",
-    element: <App />,
-    errorElement: <ErrorPage />,
-    // loader: sessionLoader,
-    children:  [
-      {
-        path: "sessions/",
-        element: <SessionList />
-      }
-    ]
-  },
-  // {
-  //   path: "sessions",
-  //   element: <SessionList />
-  // }
-])
-
-ReactDOM.createRoot(document.getElementById('root')).render(
-  <React.StrictMode>
-    <RouterProvider router={router} />
-  </React.StrictMode>,
-)

frontend/src/services/ApiService.jsx

@@ -1,17 +0,0 @@
-export async function api(url) {
-    const response = await fetch(url);
-    if (response.ok) {
-      const jsonValue = await response.json();
-      return Promise.resolve(jsonValue);
-    } else {
-      return Promise.reject('Response was not OK.');
-    }
-  }
-
-export async function getSession(sessionId) {
-    return await api(`/api/sessions/${sessionId}/`); 
-  }
-
-  export async function getSessionList() {
-    return await api(`/api/sessions/`); 
-  }

frontend/tailwind.config.cjs

@@ -1,12 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-module.exports = {
-  darkMode: "class",
-  content: ["./index.html", "./src/**/*.{js,ts,jsx,tsx}"],
-  theme: {
-    fontFamily: {
-      sans: ["Inter", "sans-serif"],
-    },
-    extend: {},
-  },
-  plugins: [require("@tailwindcss/typography"), require("@tailwindcss/forms")],
-};

frontend/vite.config.js

@@ -1,12 +0,0 @@
-import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
-
-// https://vitejs.dev/config/
-export default defineConfig({
-  plugins: [react()],
-  server: {
-    proxy: {
-      "/api": "http://127.0.0.1:8001",
-    },
-  },
-});

games/admin.py

@@ -1,11 +1,18 @@
 from django.contrib import admin
 
-from games.models import Device, Edition, 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(Edition)
 admin.site.register(Device)
+admin.site.register(ExchangeRate)

games/api.py

@@ -0,0 +1,116 @@
+from datetime import date, datetime
+from typing import List
+
+from django.contrib import messages
+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, Status
+
+from games.models import Game, PlayEvent, Session
+
+api = NinjaAPI()
+playevent_router = Router()
+game_router = Router()
+
+NOW_FACTORY = django_timezone_now
+
+
+class GameStatusUpdate(Schema):
+    status: str
+
+
+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
+
+
+@game_router.patch("/{game_id}/status", response={204: None})
+def partial_update_game(request, game_id: int, payload: GameStatusUpdate):
+    game = get_object_or_404(Game, id=game_id)
+    setattr(game, "status", payload.status)
+    game.save()
+    messages.success(request, "Status updated")
+    return Status(204, None)
+
+
+@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())
+    messages.success(request, "Game played!")
+    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 Status(204, None)
+
+
+api.add_router("/playevent", playevent_router)
+api.add_router("/games", game_router)
+
+session_router = Router()
+
+
+class SessionDeviceUpdate(Schema):
+    device_id: int
+
+
+@session_router.patch("/{session_id}/device", response={204: None})
+def partial_update_session_device(request, session_id: int, payload: SessionDeviceUpdate):
+    session = get_object_or_404(Session, id=session_id)
+    session.device_id = payload.device_id
+    session.save()
+    messages.success(request, "Device updated")
+    return Status(204, None)
+
+
+api.add_router("/session", session_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,7 +1,17 @@
 from django import forms
+from django.db import transaction
 from django.urls import reverse
 
-from games.models import Device, Edition, Game, Platform, Purchase, Session
+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(
@@ -9,23 +19,38 @@ custom_datetime_widget = forms.DateTimeInput(
 )
 autofocus_input_widget = forms.TextInput(attrs={"autofocus": "autofocus"})
 
-custom_date_widget = forms.DateInput(attrs={"type": "date"})
+
-custom_datetime_widget = forms.DateTimeInput(
+class MultipleGameChoiceField(forms.ModelMultipleChoiceField):
-    attrs={"type": "datetime-local"}, format="%Y-%m-%d %H:%M"
+    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(
+    game = SingleGameChoiceField(
-    #     queryset=Purchase.objects.filter(date_refunded=None).order_by("edition__name")
+        queryset=Game.objects.order_by("sort_name"),
-    # )
-    purchase = forms.ModelChoiceField(
-        queryset=Purchase.objects.order_by("edition__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,
@@ -33,25 +58,34 @@ class SessionForm(forms.ModelForm):
         }
         model = Session
         fields = [
-            "purchase",
+            "game",
             "timestamp_start",
             "timestamp_end",
             "duration_manual",
+            "emulated",
             "device",
             "note",
+            "mark_as_played",
         ]
 
-
+    def save(self, commit=True):
-class EditionChoiceField(forms.ModelChoiceField):
+        session = super().save(commit=False)
-    def label_from_instance(self, obj) -> str:
+        if self.cleaned_data.get("mark_as_played"):
-        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
+            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.Select):
+class IncludePlatformSelect(forms.SelectMultiple):
     def create_option(self, name, value, *args, **kwargs):
         option = super().create_option(name, value, *args, **kwargs)
-        if value:
+        if platform_id := safe_getattr(value, "instance.platform.id"):
-            option["attrs"]["data-platform"] = value.instance.platform.id
+            option["attrs"]["data-platform"] = platform_id
         return option
 
 
@@ -60,29 +94,39 @@ class PurchaseForm(forms.ModelForm):
         super().__init__(*args, **kwargs)
 
         # Automatically update related_purchase <select/>
-        # to only include purchases of the selected edition.
+        # to only include purchases of the selected game.
-        related_purchase_by_edition_url = reverse("related_purchase_by_edition")
+        related_purchase_by_game_url = reverse("games:related_purchase_by_game")
-        self.fields["edition"].widget.attrs.update(
+        self.fields["games"].widget.attrs.update(
             {
                 "hx-trigger": "load, click",
-                "hx-get": related_purchase_by_edition_url,
+                "hx-get": related_purchase_by_game_url,
                 "hx-target": "#id_related_purchase",
                 "hx-swap": "outerHTML",
             }
         )
 
-    edition = EditionChoiceField(
+    games = MultipleGameChoiceField(
-        queryset=Edition.objects.order_by("sort_name"),
+        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).order_by(
+        queryset=Purchase.objects.filter(type=Purchase.GAME),
-            "edition__sort_name"
-        ),
         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,
@@ -90,11 +134,11 @@ class PurchaseForm(forms.ModelForm):
         }
         model = Purchase
         fields = [
-            "edition",
+            "games",
             "platform",
             "date_purchased",
             "date_refunded",
-            "date_finished",
+            "infinite",
             "price",
             "price_currency",
             "ownership_type",
@@ -140,31 +184,34 @@ class GameModelChoiceField(forms.ModelChoiceField):
         return obj.sort_name
 
 
-class EditionForm(forms.ModelForm):
+class GameForm(forms.ModelForm):
-    game = GameModelChoiceField(
-        queryset=Game.objects.order_by("sort_name"),
-        widget=IncludeNameSelect(attrs={"autofocus": "autofocus"}),
-    )
     platform = forms.ModelChoiceField(
         queryset=Platform.objects.order_by("name"), required=False
     )
 
-    class Meta:
-        model = Edition
-        fields = ["game", "name", "platform", "year_released", "wikidata"]
-
-
-class GameForm(forms.ModelForm):
     class Meta:
         model = Game
-        fields = ["name", "sort_name", "year_released", "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}
 
 
@@ -173,3 +220,48 @@ class DeviceForm(forms.ModelForm):
         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/htmx_middleware.py

@@ -0,0 +1,64 @@
+import json
+
+from django.conf import settings
+from django.contrib import messages as django_messages
+from django.contrib.messages import constants as message_constants
+
+MESSAGE_LEVEL_MAP = {
+    message_constants.DEBUG: "debug",
+    message_constants.INFO: "info",
+    message_constants.SUCCESS: "success",
+    message_constants.WARNING: "warning",
+    message_constants.ERROR: "error",
+}
+
+
+class HTMXMessagesMiddleware:
+    """
+    Converts Django messages into HX-Trigger headers so toasts display
+    automatically without changes to views.
+
+    Works for HTMX requests (processed natively by HTMX client),
+    vanilla fetch() calls using fetchWithHtmxTriggers(), and is harmless
+    for full-page loads (browsers ignore HX-Trigger).
+    """
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        response = self.get_response(request)
+
+        # Skip HX-Trigger and don't consume messages if there's an HX-Redirect
+        # so the message persists in the session for the redirect target page
+        if "HX-Redirect" in response:
+            return response
+
+        min_level = message_constants.DEBUG if settings.DEBUG else message_constants.INFO
+        backend = django_messages.get_messages(request)
+        if hasattr(backend, '_set_level') and backend._get_level() > min_level:
+            backend._set_level(min_level)
+        messages = list(backend)
+        if not messages:
+            return response
+
+        triggers = []
+        for msg in messages:
+            toast_type = MESSAGE_LEVEL_MAP.get(msg.level, "info")
+            triggers.append(
+                {
+                    "message": msg.message,
+                    "type": toast_type,
+                }
+            )
+
+        if triggers:
+            # Use last message (most recent) as the primary toast
+            trigger = triggers[-1]
+            response["HX-Trigger"] = json.dumps(
+                {
+                    "show-toast": trigger,
+                }
+            )
+
+        return response

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')),
-                    "id",
+                ('name', models.CharField(max_length=255)),
-                    models.BigAutoField(
+                ('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)),
-                        auto_created=True,
+                ('created_at', models.DateTimeField(auto_now_add=True)),
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("name", models.CharField(max_length=255)),
-                ("wikidata", models.CharField(max_length=50)),
             ],
         ),
         migrations.CreateModel(
-            name="Platform",
+            name='Platform',
             fields=[
-                (
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                    "id",
+                ('name', models.CharField(max_length=255)),
-                    models.BigAutoField(
+                ('group', models.CharField(blank=True, default=None, max_length=255, null=True)),
-                        auto_created=True,
+                ('icon', models.SlugField(blank=True)),
-                        primary_key=True,
+                ('created_at', models.DateTimeField(auto_now_add=True)),
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("name", models.CharField(max_length=255)),
-                ("group", models.CharField(max_length=255)),
             ],
         ),
         migrations.CreateModel(
-            name="Purchase",
+            name='ExchangeRate',
             fields=[
-                (
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                    "id",
+                ('currency_from', models.CharField(max_length=255)),
-                    models.BigAutoField(
+                ('currency_to', models.CharField(max_length=255)),
-                        auto_created=True,
+                ('year', models.PositiveIntegerField()),
-                        primary_key=True,
+                ('rate', models.FloatField()),
-                        serialize=False,
+            ],
-                        verbose_name="ID",
+            options={
-                    ),
+                'unique_together': {('currency_from', 'currency_to', 'year')},
-                ),
+            },
-                ("date_purchased", models.DateField()),
+        ),
-                ("date_refunded", models.DateField(blank=True, null=True)),
+        migrations.CreateModel(
-                (
+            name='Game',
-                    "game",
+            fields=[
-                    models.ForeignKey(
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                        on_delete=django.db.models.deletion.CASCADE, to="games.game"
+                ('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)),
-                    "platform",
+                ('created_at', models.DateTimeField(auto_now_add=True)),
-                    models.ForeignKey(
+                ('platform', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_DEFAULT, to='games.platform')),
-                        on_delete=django.db.models.deletion.CASCADE,
+            ],
-                        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')),
-                    "id",
+                ('timestamp_start', models.DateTimeField()),
-                    models.BigAutoField(
+                ('timestamp_end', models.DateTimeField(blank=True, null=True)),
-                        auto_created=True,
+                ('duration_manual', models.DurationField(blank=True, default=datetime.timedelta(0), null=True)),
-                        primary_key=True,
+                ('duration_calculated', models.DurationField(blank=True, null=True)),
-                        serialize=False,
+                ('note', models.TextField(blank=True, null=True)),
-                        verbose_name="ID",
+                ('emulated', models.BooleanField(default=False)),
-                    ),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
-                ),
+                ('modified_at', models.DateTimeField(auto_now=True)),
-                ("timestamp_start", models.DateTimeField()),
+                ('device', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_DEFAULT, to='games.device')),
-                ("timestamp_end", models.DateTimeField()),
+                ('game', models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='sessions', to='games.game')),
-                ("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",
-                    ),
-                ),
             ],
+            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
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-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
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-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
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-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/0012_purchase_price_purchase_price_currency.py

@@ -1,23 +0,0 @@
-# Generated by Django 4.1.5 on 2023-02-18 19:53
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0011_rename_game_purchase_edition"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="purchase",
-            name="price",
-            field=models.IntegerField(default=0),
-        ),
-        migrations.AddField(
-            model_name="purchase",
-            name="price_currency",
-            field=models.CharField(default="USD", max_length=3),
-        ),
-    ]

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/0013_purchase_ownership_type.py

@@ -1,31 +0,0 @@
-# Generated by Django 4.1.5 on 2023-02-18 19:54
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0012_purchase_price_purchase_price_currency"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="purchase",
-            name="ownership_type",
-            field=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,
-            ),
-        ),
-    ]

games/migrations/0014_device_session_device.py

@@ -1,52 +0,0 @@
-# Generated by Django 4.1.5 on 2023-02-18 19:59
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0013_purchase_ownership_type"),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="Device",
-            fields=[
-                (
-                    "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"),
-                            ("co", "Console"),
-                            ("ha", "Handheld"),
-                            ("mo", "Mobile"),
-                            ("sbc", "Single-board computer"),
-                        ],
-                        default="pc",
-                        max_length=3,
-                    ),
-                ),
-            ],
-        ),
-        migrations.AddField(
-            model_name="session",
-            name="device",
-            field=models.ForeignKey(
-                null=True,
-                on_delete=django.db.models.deletion.CASCADE,
-                to="games.device",
-            ),
-        ),
-    ]

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/migrations/0015_alter_purchase_date_purchased_and_more.py

@@ -0,0 +1,39 @@
+# Generated by Django 5.1.7 on 2026-01-15 15:37
+
+import datetime
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0014_session_duration_total'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='purchase',
+            name='date_purchased',
+            field=models.DateField(verbose_name='Purchased'),
+        ),
+        migrations.AlterField(
+            model_name='purchase',
+            name='date_refunded',
+            field=models.DateField(blank=True, null=True, verbose_name='Refunded'),
+        ),
+        migrations.AlterField(
+            model_name='session',
+            name='duration_manual',
+            field=models.DurationField(blank=True, default=datetime.timedelta(0), null=True, verbose_name='Manual duration'),
+        ),
+        migrations.AlterField(
+            model_name='session',
+            name='timestamp_end',
+            field=models.DateTimeField(blank=True, null=True, verbose_name='End'),
+        ),
+        migrations.AlterField(
+            model_name='session',
+            name='timestamp_start',
+            field=models.DateTimeField(verbose_name='Start'),
+        ),
+    ]

games/migrations/0015_edition_wikidata_edition_year_released.py

@@ -1,23 +0,0 @@
-# Generated by Django 4.1.5 on 2023-02-20 14:55
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0014_device_session_device"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="edition",
-            name="wikidata",
-            field=models.CharField(blank=True, default=None, max_length=50, null=True),
-        ),
-        migrations.AddField(
-            model_name="edition",
-            name="year_released",
-            field=models.IntegerField(default=2023),
-        ),
-    ]

games/migrations/0016_add_needs_price_update.py

@@ -0,0 +1,22 @@
+# Generated by Django 6.0.1 on 2026-05-12 11:57
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0015_alter_purchase_date_purchased_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='purchase',
+            name='needs_price_update',
+            field=models.BooleanField(db_index=True, default=True),
+        ),
+        migrations.RunSQL(
+            "UPDATE games_purchase SET needs_price_update = FALSE WHERE converted_price IS NOT NULL AND converted_currency != ''",
+            reverse_sql="UPDATE games_purchase SET needs_price_update = TRUE WHERE converted_price IS NOT NULL AND converted_currency != ''",
+        ),
+    ]

games/migrations/0016_alter_edition_platform_alter_edition_year_released_and_more.py

@@ -1,51 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-06 11:10
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0015_edition_wikidata_edition_year_released"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="edition",
-            name="platform",
-            field=models.ForeignKey(
-                blank=True,
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.CASCADE,
-                to="games.platform",
-            ),
-        ),
-        migrations.AlterField(
-            model_name="edition",
-            name="year_released",
-            field=models.IntegerField(blank=True, default=None, null=True),
-        ),
-        migrations.AlterField(
-            model_name="game",
-            name="wikidata",
-            field=models.CharField(blank=True, default=None, max_length=50, null=True),
-        ),
-        migrations.AlterField(
-            model_name="platform",
-            name="group",
-            field=models.CharField(blank=True, default=None, max_length=255, null=True),
-        ),
-        migrations.AlterField(
-            model_name="session",
-            name="device",
-            field=models.ForeignKey(
-                blank=True,
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.CASCADE,
-                to="games.device",
-            ),
-        ),
-    ]

games/migrations/0016_alter_edition_platform_alter_edition_year_released_and_more_squashed_0022_rename_year_game_year_released.py

@@ -1,141 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-06 18:14
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-def rename_duplicates(apps, schema_editor):
-    Edition = apps.get_model("games", "Edition")
-
-    duplicates = (
-        Edition.objects.values("name", "platform")
-        .annotate(name_count=models.Count("id"))
-        .filter(name_count__gt=1)
-    )
-
-    for duplicate in duplicates:
-        counter = 1
-        duplicate_editions = Edition.objects.filter(
-            name=duplicate["name"], platform_id=duplicate["platform"]
-        ).order_by("id")
-
-        for edition in duplicate_editions[1:]:  # Skip the first one
-            edition.name = f"{edition.name} {counter}"
-            edition.save()
-            counter += 1
-
-
-def update_game_year(apps, schema_editor):
-    Game = apps.get_model("games", "Game")
-    Edition = apps.get_model("games", "Edition")
-
-    for game in Game.objects.filter(year__isnull=True):
-        # Try to get the first related edition with a non-null year_released
-        edition = Edition.objects.filter(game=game, year_released__isnull=False).first()
-        if edition:
-            # If an edition is found, update the game's year
-            game.year = edition.year_released
-            game.save()
-
-
-class Migration(migrations.Migration):
-    replaces = [
-        ("games", "0016_alter_edition_platform_alter_edition_year_released_and_more"),
-        ("games", "0017_alter_device_type_alter_purchase_platform"),
-        ("games", "0018_auto_20231106_1825"),
-        ("games", "0019_alter_edition_unique_together"),
-        ("games", "0020_game_year"),
-        ("games", "0021_auto_20231106_1909"),
-        ("games", "0022_rename_year_game_year_released"),
-    ]
-
-    dependencies = [
-        ("games", "0015_edition_wikidata_edition_year_released"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="edition",
-            name="platform",
-            field=models.ForeignKey(
-                blank=True,
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.CASCADE,
-                to="games.platform",
-            ),
-        ),
-        migrations.AlterField(
-            model_name="edition",
-            name="year_released",
-            field=models.IntegerField(blank=True, default=None, null=True),
-        ),
-        migrations.AlterField(
-            model_name="game",
-            name="wikidata",
-            field=models.CharField(blank=True, default=None, max_length=50, null=True),
-        ),
-        migrations.AlterField(
-            model_name="platform",
-            name="group",
-            field=models.CharField(blank=True, default=None, max_length=255, null=True),
-        ),
-        migrations.AlterField(
-            model_name="session",
-            name="device",
-            field=models.ForeignKey(
-                blank=True,
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.CASCADE,
-                to="games.device",
-            ),
-        ),
-        migrations.AlterField(
-            model_name="device",
-            name="type",
-            field=models.CharField(
-                choices=[
-                    ("pc", "PC"),
-                    ("co", "Console"),
-                    ("ha", "Handheld"),
-                    ("mo", "Mobile"),
-                    ("sbc", "Single-board computer"),
-                    ("un", "Unknown"),
-                ],
-                default="un",
-                max_length=3,
-            ),
-        ),
-        migrations.AlterField(
-            model_name="purchase",
-            name="platform",
-            field=models.ForeignKey(
-                blank=True,
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.CASCADE,
-                to="games.platform",
-            ),
-        ),
-        migrations.RunPython(
-            code=rename_duplicates,
-        ),
-        migrations.AlterUniqueTogether(
-            name="edition",
-            unique_together={("name", "platform")},
-        ),
-        migrations.AddField(
-            model_name="game",
-            name="year",
-            field=models.IntegerField(blank=True, default=None, null=True),
-        ),
-        migrations.RunPython(
-            code=update_game_year,
-        ),
-        migrations.RenameField(
-            model_name="game",
-            old_name="year",
-            new_name="year_released",
-        ),
-    ]

games/migrations/0017_alter_device_type_alter_purchase_platform.py

@@ -1,41 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-06 16:53
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0016_alter_edition_platform_alter_edition_year_released_and_more"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="device",
-            name="type",
-            field=models.CharField(
-                choices=[
-                    ("pc", "PC"),
-                    ("co", "Console"),
-                    ("ha", "Handheld"),
-                    ("mo", "Mobile"),
-                    ("sbc", "Single-board computer"),
-                    ("un", "Unknown"),
-                ],
-                default="un",
-                max_length=3,
-            ),
-        ),
-        migrations.AlterField(
-            model_name="purchase",
-            name="platform",
-            field=models.ForeignKey(
-                blank=True,
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.CASCADE,
-                to="games.platform",
-            ),
-        ),
-    ]

games/migrations/0018_auto_20231106_1825.py

@@ -1,34 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-06 17:25
-
-from django.db import migrations, models
-
-
-def rename_duplicates(apps, schema_editor):
-    Edition = apps.get_model("games", "Edition")
-
-    duplicates = (
-        Edition.objects.values("name", "platform")
-        .annotate(name_count=models.Count("id"))
-        .filter(name_count__gt=1)
-    )
-
-    for duplicate in duplicates:
-        counter = 1
-        duplicate_editions = Edition.objects.filter(
-            name=duplicate["name"], platform_id=duplicate["platform"]
-        ).order_by("id")
-
-        for edition in duplicate_editions[1:]:  # Skip the first one
-            edition.name = f"{edition.name} {counter}"
-            edition.save()
-            counter += 1
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0017_alter_device_type_alter_purchase_platform"),
-    ]
-
-    operations = [
-        migrations.RunPython(rename_duplicates),
-    ]

games/migrations/0019_alter_edition_unique_together.py

@@ -1,17 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-06 17:26
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0018_auto_20231106_1825"),
-    ]
-
-    operations = [
-        migrations.AlterUniqueTogether(
-            name="edition",
-            unique_together={("name", "platform")},
-        ),
-    ]

games/migrations/0020_game_year.py

@@ -1,18 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-06 18:05
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0019_alter_edition_unique_together"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="game",
-            name="year",
-            field=models.IntegerField(blank=True, default=None, null=True),
-        ),
-    ]

games/migrations/0021_auto_20231106_1909.py

@@ -1,24 +0,0 @@
-from django.db import migrations
-
-
-def update_game_year(apps, schema_editor):
-    Game = apps.get_model("games", "Game")
-    Edition = apps.get_model("games", "Edition")
-
-    for game in Game.objects.filter(year__isnull=True):
-        # Try to get the first related edition with a non-null year_released
-        edition = Edition.objects.filter(game=game, year_released__isnull=False).first()
-        if edition:
-            # If an edition is found, update the game's year
-            game.year = edition.year_released
-            game.save()
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0020_game_year"),
-    ]
-
-    operations = [
-        migrations.RunPython(update_game_year),
-    ]

games/migrations/0022_rename_year_game_year_released.py

@@ -1,18 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-06 18:12
-
-from django.db import migrations
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0021_auto_20231106_1909"),
-    ]
-
-    operations = [
-        migrations.RenameField(
-            model_name="game",
-            old_name="year",
-            new_name="year_released",
-        ),
-    ]

games/migrations/0023_purchase_date_finished.py

@@ -1,21 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-06 18:24
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        (
-            "games",
-            "0016_alter_edition_platform_alter_edition_year_released_and_more_squashed_0022_rename_year_game_year_released",
-        ),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="purchase",
-            name="date_finished",
-            field=models.DateField(blank=True, null=True),
-        ),
-    ]

games/migrations/0024_edition_sort_name.py

@@ -1,39 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-09 09:32
-
-from django.db import migrations, models
-
-
-def create_sort_name(apps, schema_editor):
-    Edition = apps.get_model(
-        "games", "Edition"
-    )  # Replace 'your_app_name' with the actual name of your app
-
-    for edition in Edition.objects.all():
-        name = edition.name
-        # Check for articles at the beginning of the name and move them to the end
-        if name.lower().startswith("the "):
-            sort_name = f"{name[4:]}, The"
-        elif name.lower().startswith("a "):
-            sort_name = f"{name[2:]}, A"
-        elif name.lower().startswith("an "):
-            sort_name = f"{name[3:]}, An"
-        else:
-            sort_name = name
-        # Save the sort_name back to the database
-        edition.sort_name = sort_name
-        edition.save()
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0023_purchase_date_finished"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="edition",
-            name="sort_name",
-            field=models.CharField(blank=True, default=None, max_length=255, null=True),
-        ),
-        migrations.RunPython(create_sort_name),
-    ]

games/migrations/0025_game_sort_name.py

@@ -1,39 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-09 09:32
-
-from django.db import migrations, models
-
-
-def create_sort_name(apps, schema_editor):
-    Game = apps.get_model(
-        "games", "Game"
-    )  # Replace 'your_app_name' with the actual name of your app
-
-    for game in Game.objects.all():
-        name = game.name
-        # Check for articles at the beginning of the name and move them to the end
-        if name.lower().startswith("the "):
-            sort_name = f"{name[4:]}, The"
-        elif name.lower().startswith("a "):
-            sort_name = f"{name[2:]}, A"
-        elif name.lower().startswith("an "):
-            sort_name = f"{name[3:]}, An"
-        else:
-            sort_name = name
-        # Save the sort_name back to the database
-        game.sort_name = sort_name
-        game.save()
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0024_edition_sort_name"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="game",
-            name="sort_name",
-            field=models.CharField(blank=True, default=None, max_length=255, null=True),
-        ),
-        migrations.RunPython(create_sort_name),
-    ]

games/migrations/0026_purchase_type.py

@@ -1,27 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-14 08:35
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0025_game_sort_name"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="purchase",
-            name="type",
-            field=models.CharField(
-                choices=[
-                    ("game", "Game"),
-                    ("dlc", "DLC"),
-                    ("season_pass", "Season Pass"),
-                    ("battle_pass", "Battle Pass"),
-                ],
-                default="game",
-                max_length=255,
-            ),
-        ),
-    ]

games/migrations/0027_purchase_related_purchase.py

@@ -1,24 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-14 08:41
-
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0026_purchase_type"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="purchase",
-            name="related_purchase",
-            field=models.ForeignKey(
-                blank=True,
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.SET_NULL,
-                to="games.purchase",
-            ),
-        ),
-    ]

games/migrations/0028_purchase_name.py

@@ -1,25 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-14 11:05
-
-from django.db import migrations, models
-from games.models import Purchase
-
-
-def null_game_name(apps, schema_editor):
-    Purchase.objects.filter(type=Purchase.GAME).update(name=None)
-
-
-class Migration(migrations.Migration):
-    dependencies = [
-        ("games", "0027_purchase_related_purchase"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="purchase",
-            name="name",
-            field=models.CharField(
-                blank=True, default="Unknown Name", max_length=255, null=True
-            ),
-        ),
-        migrations.RunPython(null_game_name),
-    ]

games/migrations/0029_alter_purchase_related_purchase.py

@@ -1,26 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-14 21:19
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0028_purchase_name"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="purchase",
-            name="related_purchase",
-            field=models.ForeignKey(
-                blank=True,
-                default=None,
-                null=True,
-                on_delete=django.db.models.deletion.SET_NULL,
-                related_name="related_purchases",
-                to="games.purchase",
-            ),
-        ),
-    ]

games/migrations/0030_alter_purchase_name.py

@@ -1,18 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-15 12:04
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0029_alter_purchase_related_purchase"),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name="purchase",
-            name="name",
-            field=models.CharField(blank=True, default="", max_length=255, null=True),
-        ),
-    ]

games/migrations/0031_device_created_at_edition_created_at_game_created_at_and_more.py

@@ -1,44 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-15 13:51
-
-import django.utils.timezone
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0030_alter_purchase_name"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="device",
-            name="created_at",
-            field=models.DateTimeField(default=django.utils.timezone.now),
-        ),
-        migrations.AddField(
-            model_name="edition",
-            name="created_at",
-            field=models.DateTimeField(default=django.utils.timezone.now),
-        ),
-        migrations.AddField(
-            model_name="game",
-            name="created_at",
-            field=models.DateTimeField(default=django.utils.timezone.now),
-        ),
-        migrations.AddField(
-            model_name="platform",
-            name="created_at",
-            field=models.DateTimeField(default=django.utils.timezone.now),
-        ),
-        migrations.AddField(
-            model_name="purchase",
-            name="created_at",
-            field=models.DateTimeField(default=django.utils.timezone.now),
-        ),
-        migrations.AddField(
-            model_name="session",
-            name="created_at",
-            field=models.DateTimeField(default=django.utils.timezone.now),
-        ),
-    ]

games/migrations/0032_alter_session_options_session_modified_at_and_more.py

@@ -1,52 +0,0 @@
-# Generated by Django 4.1.5 on 2023-11-15 18:02
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0031_device_created_at_edition_created_at_game_created_at_and_more"),
-    ]
-
-    operations = [
-        migrations.AlterModelOptions(
-            name="session",
-            options={"get_latest_by": "timestamp_start"},
-        ),
-        migrations.AddField(
-            model_name="session",
-            name="modified_at",
-            field=models.DateTimeField(auto_now=True),
-        ),
-        migrations.AlterField(
-            model_name="device",
-            name="created_at",
-            field=models.DateTimeField(auto_now_add=True),
-        ),
-        migrations.AlterField(
-            model_name="edition",
-            name="created_at",
-            field=models.DateTimeField(auto_now_add=True),
-        ),
-        migrations.AlterField(
-            model_name="game",
-            name="created_at",
-            field=models.DateTimeField(auto_now_add=True),
-        ),
-        migrations.AlterField(
-            model_name="platform",
-            name="created_at",
-            field=models.DateTimeField(auto_now_add=True),
-        ),
-        migrations.AlterField(
-            model_name="purchase",
-            name="created_at",
-            field=models.DateTimeField(auto_now_add=True),
-        ),
-        migrations.AlterField(
-            model_name="session",
-            name="created_at",
-            field=models.DateTimeField(auto_now_add=True),
-        ),
-    ]

games/models.py

@@ -1,62 +1,113 @@
+import logging
 from datetime import timedelta
 
+import requests
 from django.core.exceptions import ValidationError
 from django.db import models
-from django.core.exceptions import ValidationError
+from django.db.models import F, Q, Sum
-from django.db.models import F, Manager, 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
 
+logger = logging.getLogger("games")
+
 
 class Game(models.Model):
+    class Meta:
+        unique_together = [["name", "platform", "year_released"]]
+
     name = models.CharField(max_length=255)
-    sort_name = models.CharField(max_length=255, null=True, blank=True, default=None)
+    sort_name = models.CharField(max_length=255, blank=True, default="")
     year_released = models.IntegerField(null=True, blank=True, default=None)
-    wikidata = models.CharField(max_length=50, 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 or
+                self.playevents.filter(ended__isnull=False).exists())
+
+    def abandoned(self):
+        return self.status == self.Status.ABANDONED
+
+    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)
+
+
+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, 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):
-        def get_sort_name(name):
+        if not self.icon:
-            articles = ["a", "an", "the"]
+            self.icon = slugify(self.name)
-            name_parts = name.split()
-            first_word = name_parts[0].lower()
-            if first_word in articles:
-                return f"{' '.join(name_parts[1:])}, {name_parts[0]}"
-            else:
-                return name
-
-        self.sort_name = get_sort_name(self.name)
-        super().save(*args, **kwargs)
-
-
-class Edition(models.Model):
-    class Meta:
-        unique_together = [["name", "platform"]]
-
-    game = models.ForeignKey("Game", on_delete=models.CASCADE)
-    name = models.CharField(max_length=255)
-    platform = models.ForeignKey("Platform", on_delete=models.CASCADE)
-    year_released = models.IntegerField(default=datetime.today().year)
-    wikidata = models.CharField(max_length=50, null=True, blank=True, default=None)
-
-    def __str__(self):
-        return self.sort_name
-
-    def save(self, *args, **kwargs):
-        def get_sort_name(name):
-            articles = ["a", "an", "the"]
-            name_parts = name.split()
-            first_word = name_parts[0].lower()
-            if first_word in articles:
-                return f"{' '.join(name_parts[1:])}, {name_parts[0]}"
-            else:
-                return name
-
-        self.sort_name = get_sort_name(self.name)
         super().save(*args, **kwargs)
 
 
@@ -67,12 +118,22 @@ class PurchaseQueryset(models.QuerySet):
     def not_refunded(self):
         return self.filter(date_refunded__isnull=True)
 
-    def finished(self):
-        return self.filter(date_finished__isnull=False)
-
     def games_only(self):
         return self.filter(type=Purchase.GAME)
 
+    def finished(self):
+        return self.filter(
+            Q(games__status="f") | Q(games__playevents__ended__isnull=False)
+        ).distinct()
+
+    def abandoned(self):
+        return self.filter(games__status="a").distinct()
+
+    def dropped(self):
+        return self.filter(
+            Q(games__status="a") | Q(date_refunded__isnull=False)
+        ).distinct()
+
 
 class Purchase(models.Model):
     PHYSICAL = "ph"
@@ -106,52 +167,92 @@ class Purchase(models.Model):
 
     objects = PurchaseQueryset().as_manager()
 
-    edition = models.ForeignKey("Edition", on_delete=models.CASCADE)
+    games = models.ManyToManyField(Game, related_name="purchases")
+
     platform = models.ForeignKey(
-        "Platform", on_delete=models.CASCADE, default=None, null=True, blank=True
+        Platform, on_delete=models.CASCADE, default=None, null=True, blank=True
     )
-    date_purchased = models.DateField()
+    date_purchased = models.DateField(verbose_name="Purchased")
-    date_refunded = models.DateField(blank=True, null=True)
+    date_refunded = models.DateField(blank=True, null=True, verbose_name="Refunded")
-    date_finished = models.DateField(blank=True, null=True)
+    infinite = models.BooleanField(default=False)
-    price = models.IntegerField(default=0)
+    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="")
+    needs_price_update = models.BooleanField(default=True, db_index=True)
+    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, default="", null=True, blank=True)
+    name = models.CharField(max_length=255, blank=True, default="")
     related_purchase = models.ForeignKey(
-        "Purchase", on_delete=models.SET_NULL, default=None, null=True, blank=True
+        "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):
-        platform_info = self.platform
+        return self.standardized_name
-        if self.platform != self.edition.platform:
+
-            platform_info = f"{self.edition.platform} version on {self.platform}"
+    @property
-        return f"{self.edition} ({platform_info}, {self.edition.year_released}, {self.get_ownership_type_display()})"
+    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 refund(self):
+        self.date_refunded = timezone.now()
+        self.save()
+
     def save(self, *args, **kwargs):
-        if self.type == Purchase.GAME:
+        if self.type != Purchase.GAME and not self.related_purchase:
-            self.name = ""
-        elif self.type != Purchase.GAME and not self.related_purchase:
             raise ValidationError(
                 f"{self.get_type_display()} must have a related purchase."
             )
         super().save(*args, **kwargs)
 
 
-class Platform(models.Model):
-    name = models.CharField(max_length=255)
-    group = models.CharField(max_length=255, null=True, blank=True, default=None)
-    created_at = models.DateTimeField(auto_now_add=True)
-
-    def __str__(self):
-        return self.name
-
-
 class SessionQuerySet(models.QuerySet):
     def total_duration_formatted(self):
         return format_duration(self.total_duration_unformatted())
@@ -162,32 +263,66 @@ class SessionQuerySet(models.QuerySet):
         )
         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):
     class Meta:
         get_latest_by = "timestamp_start"
 
-    purchase = models.ForeignKey("Purchase", on_delete=models.CASCADE)
+    game = models.ForeignKey(
-    timestamp_start = models.DateTimeField()
+        Game,
-    timestamp_end = models.DateTimeField(blank=True, null=True)
+        on_delete=models.CASCADE,
-    duration_manual = models.DurationField(blank=True, null=True, default=timedelta(0))
+        null=True,
-    duration_calculated = models.DurationField(blank=True, 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.CASCADE,
+        on_delete=models.SET_DEFAULT,
         null=True,
         blank=True,
         default=None,
     )
-    note = models.TextField(blank=True, null=True)
+    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.is_manual() else ""
+        mark = "*" if self.is_manual() else ""
-        return f"{str(self.purchase)} {str(self.timestamp_start.date())} ({self.duration_formatted()}{mark})"
+        return f"{str(self.game)} {str(self.timestamp_start.date())} ({self.duration_formatted()}{mark})"
 
     def finish_now(self):
         self.timestamp_end = timezone.now()
@@ -195,31 +330,20 @@ class Session(models.Model):
     def start_now():
         self.timestamp_start = timezone.now()
 
-    def duration_seconds(self) -> timedelta:
-        manual = timedelta(0)
-        calculated = timedelta(0)
-        if self.is_manual():
-            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())
-
     def duration_formatted(self) -> str:
-        result = format_duration(self.duration_seconds(), "%02.0H:%02.0m")
+        result = format_duration(self.duration_total, "%02.1H")
         return result
 
+    def duration_formatted_with_mark(self) -> str:
+        mark = "*" if self.is_manual() else ""
+        return f"{self.duration_formatted()}{mark}"
+
     def is_manual(self) -> bool:
         return not self.duration_manual == timedelta(0)
 
-    @property
+    def save(self, *args, **kwargs) -> None:
-    def duration_sum(self) -> str:
+        if not isinstance(self.duration_manual, timedelta):
-        return Session.objects.all().total_duration_formatted()
+            self.duration_manual = timedelta(0)
-
-    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)
 
         if not self.device:
             default_device, _ = Device.objects.get_or_create(
@@ -230,12 +354,12 @@ class Session(models.Model):
 
 
 class Device(models.Model):
-    PC = "pc"
+    PC = "PC"
-    CONSOLE = "co"
+    CONSOLE = "Console"
-    HANDHELD = "ha"
+    HANDHELD = "Handheld"
-    MOBILE = "mo"
+    MOBILE = "Mobile"
-    SBC = "sbc"
+    SBC = "Single-board computer"
-    UNKNOWN = "un"
+    UNKNOWN = "Unknown"
     DEVICE_TYPES = [
         (PC, "PC"),
         (CONSOLE, "Console"),
@@ -245,8 +369,115 @@ class Device(models.Model):
         (UNKNOWN, "Unknown"),
     ]
     name = models.CharField(max_length=255)
-    type = models.CharField(max_length=3, choices=DEVICE_TYPES, default=UNKNOWN)
+    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.get_type_display()})"
+        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/signals.py

@@ -0,0 +1,112 @@
+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_delete,
+    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(pre_save, sender=Purchase)
+def store_purchase_price_snapshot(sender, instance, **kwargs):
+    """Store old price values before save so we can detect changes."""
+    if instance.pk is not None:
+        try:
+            old_instance = sender.objects.get(pk=instance.pk)
+            instance._old_price = old_instance.price
+            instance._old_currency = old_instance.price_currency
+        except sender.DoesNotExist:
+            pass
+
+
+@receiver(post_save, sender=Purchase)
+def mark_needs_price_update(sender, instance, created, **kwargs):
+    """Mark purchase for price update if price or currency changed."""
+    if not created and hasattr(instance, "_old_price"):
+        if (
+            instance.price != instance._old_price
+            or instance.price_currency != instance._old_currency
+        ):
+            sender.objects.filter(pk=instance.pk).update(needs_price_update=True)
+
+
+@receiver(m2m_changed, sender=Purchase.games.through)
+def update_num_purchases(sender, instance, action, reverse, **kwargs):
+    if not reverse and action.startswith("post_"):
+        instance.num_purchases = instance.games.count()
+        instance.updated_at = now()
+        instance.save(update_fields=["num_purchases", "updated_at"])
+
+
+@receiver(pre_delete, sender=Game)
+def update_purchase_counts_on_game_delete(sender, instance, **kwargs):
+    """
+    Update num_purchases on related Purchase objects when a Game is deleted.
+    m2m_changed is not fired when a related object is deleted.
+    """
+    for purchase in instance.purchases.all():
+        if purchase.num_purchases > 0:
+            purchase.num_purchases -= 1
+            if purchase.num_purchases == 0:
+                purchase.delete()
+            else:
+                purchase.updated_at = now()
+                purchase.save(update_fields=["num_purchases", "updated_at"])
+
+
+@receiver([post_save, post_delete], sender=Session)
+def update_game_playtime(sender, instance, **kwargs):
+    # During cascade deletes the related Game may already have been removed.
+    # Use the FK id to look up the Game safely and bail out if it no longer exists.
+    game_pk = getattr(instance, "game_id", None)
+    if not game_pk:
+        return
+    game = Game.objects.filter(pk=game_pk).first()
+    if not game:
+        return
+
+    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")