Initial commit

.github/workflows/build-docker.yml

@@ -9,42 +9,28 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-
+      - uses: actions/setup-python@v4
-      - name: Install uv
-        uses: astral-sh/setup-uv@v5
         with:
-          enable-cache: false
+          python-version: 3.12
-          python-version: "3.14"
+      - run: |
-
+          python -m pip install poetry
-      - name: Install dependencies
+          poetry install
-        run: uv sync --frozen
+          poetry env info
-
+          poetry run python manage.py migrate
-      - name: Run Migrations
+          # PROD=1 poetry run pytest
-        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
-      
+      - uses: docker/setup-buildx-action@v3
-      - name: Set Version
+      - uses: docker/build-push-action@v5
-        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
+    env:
-          # cache-to: type=gha,mode=max
+      VERSION_NUMBER: 1.5.1

.vscode/launch.json

@@ -1,26 +0,0 @@
-{
-    // 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"
-        }
-    ]
-}

CHANGELOG.md

@@ -1,20 +1,6 @@
 ## Unreleased
 
-### Improved
+## New
-* 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
@@ -22,10 +8,8 @@
 * 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
+## Improved
 * mark refunded purchases red on game overview
 * increase session count on game overview when starting a new session
 * game overview:
@@ -36,7 +20,7 @@
 * 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
+## Fixed
 * Fix title not being displayed on the Recent sessions page
 * Avoid errors when displaying game overview with zero sessions
 

Dockerfile

@@ -1,41 +1,45 @@
-FROM ghcr.io/astral-sh/uv:python3.14-bookworm-slim AS builder
+FROM python:3.12.0-slim-bullseye
 
-ENV UV_LINK_MODE=copy \
+ENV VERSION_NUMBER=1.5.2 \
-    UV_COMPILE_BYTECODE=1 \
+    PROD=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 \
-    PATH="/home/timetracker/app/.venv/bin:$PATH"
+    PYTHONFAULTHANDLER=1 \
+    PYTHONHASHSEED=random \
+    PYTHONDONTWRITEBYTECODE=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1 \
+    PIP_DEFAULT_TIMEOUT=100 \
+    PIP_ROOT_USER_ACTION=ignore \
+    POETRY_NO_INTERACTION=1 \
+    POETRY_VIRTUALENVS_CREATE=false \
+    POETRY_CACHE_DIR='/var/cache/pypoetry' \
+    POETRY_HOME='/usr/local'
+
+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/
-COPY --from=builder --chown=timetracker:timetracker /home/timetracker/app /home/timetracker/app
+RUN chown -R timetracker:timetracker /home/timetracker/app
-
+COPY entrypoint.sh /
-COPY --chown=timetracker:timetracker entrypoint.sh /
 RUN chmod +x /entrypoint.sh
 
+RUN --mount=type=cache,target="$POETRY_CACHE_DIR" \
+    echo "$PROD" \
+    && poetry version \
+    && poetry run pip install -U pip \
+    && poetry install --only main --no-interaction --no-ansi --sync
+
 USER timetracker
 
-ENV VERSION_NUMBER=1.6.1
-
 EXPOSE 8000
 CMD [ "/entrypoint.sh" ]

Makefile

@@ -9,68 +9,64 @@ npm:
 	npm install
 
 css: common/input.css
-	npx @tailwindcss/cli -i ./common/input.css -o  ./games/static/base.css
+	npx tailwindcss -i ./common/input.css -o  ./games/static/base.css
 
 makemigrations:
-	uv run python manage.py makemigrations
+	poetry run python manage.py makemigrations
 
 migrate: makemigrations
-	uv run python manage.py migrate
+	poetry run python manage.py migrate
 
 init:
-	uv install $(PYTHON_VERSION)
+	pyenv install -s $(PYTHON_VERSION)
-	uv sync
+	pyenv local $(PYTHON_VERSION)
+	pip install poetry
+	poetry install
 	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" \
+		"poetry run python -Wa manage.py runserver" \
-		"npx @tailwindcss/cli -i ./common/input.css -o ./games/static/base.css --watch"
+		"npx tailwindcss -i ./common/input.css -o ./games/static/base.css --watch"
 
 
 caddy:
 	caddy run --watch
 
 dev-prod: migrate collectstatic
-	PROD=1 uv run python -m gunicorn --bind 0.0.0.0:8001 timetracker.asgi:application -k uvicorn.workers.UvicornWorker
+	PROD=1 poetry run python -m gunicorn --bind 0.0.0.0:8001 timetracker.asgi:application -k uvicorn.workers.UvicornWorker
 
 dumpgames:
-	uv run python manage.py dumpdata --format yaml games --output tracker_fixture.yaml
+	poetry run python manage.py dumpdata --format yaml games --output tracker_fixture.yaml
 
 loadplatforms:
-	uv run python manage.py loaddata platforms.yaml
+	poetry run python manage.py loaddata platforms.yaml
 
 loadall:
-	uv run python manage.py loaddata data.yaml
+	poetry run python manage.py loaddata data.yaml
 
 loadsample:
-	uv run python manage.py loaddata sample.yaml
+	poetry run python manage.py loaddata sample.yaml
 
 createsuperuser:
-	uv run python manage.py createsuperuser
+	poetry run python manage.py createsuperuser
 
 shell:
-	uv run python manage.py shell
+	poetry run python manage.py shell
 
 collectstatic:
-	uv run python manage.py collectstatic --clear --no-input
+	poetry run python manage.py collectstatic --clear --no-input
 
-uv.lock: pyproject.toml
+poetry.lock: pyproject.toml
-	uv sync
+	poetry install
 
-test: uv.lock
+test: poetry.lock
-	uv run --with pytest-django pytest
+	poetry run pytest
 
 date:
-	uv run python -c 'import datetime; from zoneinfo import ZoneInfo; print(datetime.datetime.isoformat(datetime.datetime.now(ZoneInfo("Europe/Prague")), timespec="minutes", sep=" "))'
+	poetry 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/*

common/COMPONENT_IMPROVEMENTS.md

@@ -1,46 +0,0 @@
-# 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

@@ -1,48 +1,26 @@
-import hashlib
+from random import choices as random_choices
-import json
+from string import ascii_lowercase
-from functools import lru_cache
+from typing import Any, Callable
-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.urls import NoReverseMatch, reverse
 from django.utils.safestring import SafeText, mark_safe
 
 from common.utils import truncate
-from games.models import Game, Purchase, Session
+from games.models import Purchase
 
 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,
+    attributes: list[HTMLAttribute] = [],
-    children: list[HTMLTag] | HTMLTag | None = None,
+    children: list[HTMLTag] | HTMLTag = [],
     template: str = "",
     tag_name: str = "",
-) -> SafeText:
+) -> HTMLTag:
-    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):
@@ -54,37 +32,33 @@ def Component(
         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)}"
+        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_to_string(
-        tag = _render_cached(template, json.dumps(context, sort_keys=True))
+            template,
+            {name: value for name, value in attributes}
+            | {"slot": mark_safe("\n".join(children))},
+        )
     return mark_safe(tag)
 
 
-def randomid(seed: str = "", content: str = "", length: int = 10) -> str:
+def randomid(seed: str = "", length: int = 10) -> str:
-    if not seed and not content:
+    return seed + "".join(random_choices(ascii_lowercase, k=length))
-        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,
+    children: list[HTMLTag] = [],
-    attributes: list[HTMLAttribute] | None = None,
+    attributes: list[HTMLAttribute] = [],
 ) -> 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}")
+    id = randomid()
     return Component(
         attributes=attributes
         + [
@@ -131,71 +105,60 @@ def PopoverTruncated(
 
 
 def A(
-    attributes: list[HTMLAttribute] | None = None,
+    attributes: list[HTMLAttribute] = [],
-    children: list[HTMLTag] | HTMLTag | None = None,
+    children: list[HTMLTag] | HTMLTag = [],
-    url_name: str | None = None,
+    url: str | Callable[..., Any] = "",
-    href: str | None = None,
+):
-) -> SafeText:
     """
-    Returns an anchor <a> tag.
+    Returns the HTML tag "a".
-
+    "url" can either be:
-    Accepts one of two mutually-exclusive URL specifications:
+        - URL (string)
-        - url_name: URL pattern name, resolved via reverse()
+        - path name passed to reverse() (string)
-        - href: Literal path string passed through as-is
+        - function
     """
-    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:
+    if url:
-        additional_attributes = [("href", reverse(url_name))]
+        if type(url) is str:
-    elif href is not None:
+            try:
-        additional_attributes = [("href", href)]
+                url_result = reverse(url)
+            except NoReverseMatch:
+                url_result = url
+        elif callable(url):
+            url_result = url()
+        else:
+            raise TypeError("'url' is neither str nor function.")
+        additional_attributes = [("href", url_result)]
     return Component(
         tag_name="a", attributes=attributes + additional_attributes, children=children
     )
 
 
 def Button(
-    attributes: list[HTMLAttribute] | None = None,
+    attributes: list[HTMLAttribute] = [],
-    children: list[HTMLTag] | HTMLTag | None = None,
+    children: list[HTMLTag] | HTMLTag = [],
     size: str = "base",
     icon: bool = False,
     color: str = "blue",
-) -> SafeText:
+):
-    attributes = attributes or []
-    children = children or []
     return Component(
         template="cotton/button.html",
-        attributes=attributes
+        attributes=attributes + [("size", size), ("icon", icon), ("color", color)],
-        + [
-            ("size", size),
-            ("icon", icon),
-            ("color", color),
-            ("class", "hover:cursor-pointer"),
-        ],
         children=children,
     )
 
 
 def Div(
-    attributes: list[HTMLAttribute] | None = None,
+    attributes: list[HTMLAttribute] = [],
-    children: list[HTMLTag] | HTMLTag | None = None,
+    children: list[HTMLTag] | HTMLTag = [],
-) -> 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,
+    attributes: list[HTMLAttribute] = [],
-    children: list[HTMLTag] | HTMLTag | None = None,
+    children: list[HTMLTag] | HTMLTag = [],
-) -> SafeText:
+):
-    attributes = attributes or []
-    children = children or []
     return Component(
         tag_name="input", attributes=attributes + [("type", type)], children=children
     )
@@ -204,11 +167,9 @@ def Input(
 def Form(
     action="",
     method="get",
-    attributes: list[HTMLAttribute] | None = None,
+    attributes: list[HTMLAttribute] = [],
-    children: list[HTMLTag] | HTMLTag | None = None,
+    children: list[HTMLTag] | HTMLTag = [],
-) -> SafeText:
+):
-    attributes = attributes or []
-    children = children or []
     return Component(
         tag_name="form",
         attributes=attributes + [("action", action), ("method", method)],
@@ -218,9 +179,8 @@ def Form(
 
 def Icon(
     name: str,
-    attributes: list[HTMLAttribute] | None = None,
+    attributes: list[HTMLAttribute] = [],
-) -> SafeText:
+):
-    attributes = attributes or []
     try:
         result = Component(template=f"cotton/icon/{name}.html", attributes=attributes)
     except TemplateDoesNotExist:
@@ -228,28 +188,49 @@ def Icon(
     return result
 
 
+def LinkedNameWithPlatformIcon(name: str, game_id: int, platform: str) -> SafeText:
+    link = reverse("view_game", args=[int(game_id)])
+    a_content = Div(
+        [("class", "inline-flex gap-2 items-center")],
+        [
+            Icon(
+                platform.icon,
+                [("title", platform.name)],
+            ),
+            PopoverTruncated(name),
+        ],
+    )
+
+    return mark_safe(
+        A(
+            url=link,
+            children=[a_content],
+        ),
+    )
+
+
 def LinkedPurchase(purchase: Purchase) -> SafeText:
-    link = reverse("games:view_purchase", args=[int(purchase.id)])
+    link = reverse("view_purchase", args=[int(purchase.id)])
     link_content = ""
     popover_content = ""
-    game_count = purchase.games.count()
+    edition_count = purchase.editions.count()
     popover_if_not_truncated = False
-    if game_count == 1:
+    if edition_count == 1:
-        link_content += purchase.games.first().name
+        link_content += purchase.editions.first().name
         popover_content = link_content
-    if game_count > 1:
+    if edition_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"
+            link_content += f"{edition_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())}
+            {"".join(f"<li>{edition.name}</li>" for edition in purchase.editions.all())}
         </ul>
         """
-    icon = purchase.platform.icon if game_count == 1 else "unspecified"
+    icon = purchase.platform.icon if edition_count == 1 else "unspecified"
     if link_content == "":
         raise ValueError("link_content is empty!!")
     a_content = Div(
@@ -266,79 +247,27 @@ def LinkedPurchase(purchase: Purchase) -> SafeText:
             ),
         ],
     )
-    return A(href=link, children=[a_content])
+    return mark_safe(A(url=link, children=[a_content]))
 
 
-def NameWithIcon(
+def NameWithPlatformIcon(name: str, platform: str) -> SafeText:
-    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
+            PopoverTruncated(name),
-            else "",
-            Icon("emulated", [("title", "Emulated")]) if final_emulated else "",
-            PopoverTruncated(_name),
         ],
     )
 
-    return (
+    return mark_safe(content)
-        A(
-            href=link,
-            children=[content],
-        )
-        if create_link
-        else content
-    )
 
 
-def _resolve_name_with_icon(
+def PurchasePrice(purchase) -> str:
-    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

@@ -1,143 +1,127 @@
-@import 'tailwindcss';
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
 
-@plugin '@tailwindcss/typography';
+@font-face {
-@plugin '@tailwindcss/forms';
+  font-family: "IBM Plex Mono";
-@plugin 'flowbite/plugin';
+  src: url("fonts/IBMPlexMono-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+}
 
-@source "../node_modules/flowbite";
+@font-face {
-@import "flowbite/src/themes/default";
+  font-family: "IBM Plex Sans";
+  src: url("fonts/IBMPlexSans-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+}
 
-@custom-variant dark (&:is(.dark *));
+@font-face {
+  font-family: "IBM Plex Serif";
+  src: url("fonts/IBMPlexSerif-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
+}
 
-@theme {
+@font-face {
-  --font-sans:
+  font-family: "IBM Plex Serif";
-    IBM Plex Sans, ui-sans-serif, system-ui, sans-serif, 'Apple Color Emoji',
+  src: url("fonts/IBMPlexSerif-Bold.woff2") format("woff2");
-    'Segoe UI Emoji', 'Segoe UI Symbol', 'Noto Color Emoji';
+  font-weight: 700;
-  --font-mono:
+  font-style: normal;
-    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;
+@font-face {
-  --color-background: #1f2937;
+  font-family: "IBM Plex Sans Condensed";
+  src: url("fonts/IBMPlexSansCondensed-Regular.woff2") format("woff2");
+  font-weight: 400;
+  font-style: normal;
 }
 
 
-/*
+/* a:hover {
-  The default border color has changed to `currentcolor` in Tailwind CSS v4,
+  text-decoration-color: #ff4400;
-  so we've added these compatibility styles to make sure everything still
+  color: rgb(254, 185, 160);
-  looks the same as it did with Tailwind CSS v3.
+  transition: all 0.2s ease-out;
+} */
 
-  If we ever want to remove these styles, we need to add an explicit border
+form label {
-  color utility to any element that depends on these defaults.
+  @apply dark:text-slate-400;
-*/
-@layer base {
-  *,
-  ::after,
-  ::before,
-  ::backdrop,
-  ::file-selector-button {
-    border-color: var(--color-gray-200, currentcolor);
-  }
 }
 
-@utility min-w-20char {
+.responsive-table {
-  min-width: 20ch;
+  @apply dark:text-white mx-auto table-fixed;
 }
 
-@utility max-w-20char {
+.responsive-table tr:nth-child(even) {
-  max-width: 20ch;
+  @apply bg-slate-800
 }
 
-@utility min-w-30char {
+.responsive-table tbody tr:nth-child(odd) {
-  min-width: 30ch;
+  @apply bg-slate-900
 }
 
-@utility max-w-30char {
+.responsive-table thead th {
-  max-width: 30ch;
+  @apply text-left border-b-2 border-b-slate-500 text-xl;
 }
 
-@utility max-w-35char {
+.responsive-table thead th:not(:first-child),
-  max-width: 35ch;
+.responsive-table td:not(:first-child) {
-}
+  @apply border-l border-l-slate-500;
-
-@utility max-w-40char {
-  max-width: 40ch;
 }
 
 @layer utilities {
-  @font-face {
+  .min-w-20char {
-    font-family: 'IBM Plex Mono';
+    min-width: 20ch;
-    src: url('fonts/IBMPlexMono-Regular.woff2') format('woff2');
-    font-weight: 400;
-    font-style: normal;
   }
+  .max-w-20char {
+    max-width: 20ch;
+  }
+  .min-w-30char {
+    min-width: 30ch;
+  }
+  .max-w-30char {
+    max-width: 30ch;
+  }
+  .max-w-35char {
+    max-width: 35ch;
+  }
+  .max-w-40char {
+    max-width: 40ch;
+  }
+}
 
-  @font-face {
+form input,
-    font-family: 'IBM Plex Sans';
+select,
-    src: url('fonts/IBMPlexSans-Regular.woff2') format('woff2');
+textarea {
-    font-weight: 400;
+  @apply dark:border dark:border-slate-900 dark:bg-slate-500 dark:text-slate-100;
-    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;
+  @apply dark:bg-slate-700 dark:text-slate-400;
-   
 }
 
 .errorlist {
   @apply mt-4 mb-1 pl-3 py-2 bg-red-600 text-slate-200 w-[300px];
 }
 
+@media screen and (min-width: 768px) {
+  form input,
+  select,
+  textarea {
+    width: 300px;
+  }
+}
+
+@media screen and (max-width: 768px) {
+  form input,
+  select,
+  textarea {
+    width: 150px;
+  }
+}
+
 #button-container button {
   @apply mx-1;
 }
@@ -147,7 +131,7 @@ textarea:disabled {
 }
 
 .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;
+  @apply inline-block px-6 py-2.5 bg-blue-600 text-white font-medium text-xs leading-tight uppercase rounded shadow-md hover:bg-blue-700 hover:shadow-lg focus:bg-blue-700 focus:shadow-lg focus:outline-none focus:ring-0 active:bg-blue-800 active:shadow-lg transition duration-150 ease-in-out;
 }
 
 .markdown-content ul {
@@ -178,56 +162,10 @@ textarea:disabled {
     padding-left: 1em;
 }
 
-#add-form {
+/* .truncate-container {
-  label + select, input, textarea {
+  @apply inline-block relative;
-    @apply mt-1;
+  a {
-  }
+    @apply inline-block truncate max-w-20char transition-all group-hover:absolute group-hover:max-w-none group-hover:-top-8 group-hover:-left-6 group-hover:min-w-60 group-hover:px-6 group-hover:py-3.5 group-hover:bg-purple-600 group-hover:rounded-sm group-hover:outline-dashed group-hover:outline-purple-400 group-hover:outline-4;
-  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

@@ -13,7 +13,7 @@ durationformat_manual: str = "%H hours"
 
 
 def _safe_timedelta(duration: timedelta | int | None):
-    if duration is None:
+    if duration == None:
         return timedelta(0)
     elif isinstance(duration, int):
         return timedelta(seconds=duration)

common/utils.py

@@ -1,13 +1,5 @@
-import operator
-from dataclasses import dataclass
 from datetime import date
-from functools import reduce, wraps
+from typing import Any, Generator, TypeVar
-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:
@@ -44,7 +36,7 @@ def safe_getattr(obj: object, attr_chain: str, default: Any | None = None) -> ob
 
 def truncate_(input_string: str, length: int = 30, ellipsis: str = "…") -> str:
     return (
-        (f"{input_string[: length - len(ellipsis)].rstrip()}{ellipsis}")
+        (f"{input_string[:length-len(ellipsis)].rstrip()}{ellipsis}")
         if len(input_string) > length
         else input_string
     )
@@ -58,12 +50,12 @@ def truncate(
         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[: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}"
+        else f"{input_string[:length - len(ellipsis) - len(endpart)].rstrip()}{ellipsis}{endpart}"
     )
 
 
@@ -89,79 +81,3 @@ def generate_split_ranges(
 
 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

@@ -1,33 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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()

entrypoint.sh

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

games/admin.py

@@ -2,6 +2,7 @@ from django.contrib import admin
 
 from games.models import (
     Device,
+    Edition,
     ExchangeRate,
     Game,
     Platform,
@@ -14,5 +15,6 @@ 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

@@ -1,116 +0,0 @@
-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,10 +1,9 @@
-# from datetime import timedelta
+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
-# from django.utils.timezone import now
 
 
 class GamesConfig(AppConfig):
@@ -12,32 +11,20 @@ class GamesConfig(AppConfig):
     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.models import Schedule
-    # from django_q.tasks import schedule
+    from django_q.tasks import schedule
 
-    # if not Schedule.objects.filter(name="Update converted prices").exists():
+    if not Schedule.objects.filter(name="Update converted prices").exists():
-    #     schedule(
+        schedule(
-    #         "games.tasks.convert_prices",
+            "games.tasks.convert_prices",
-    #         name="Update converted prices",
+            name="Update converted prices",
-    #         schedule_type=Schedule.MINUTES,
+            schedule_type=Schedule.MINUTES,
-    #         next_run=now() + timedelta(seconds=30),
+            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
 

games/fixtures/exchangerates.yaml

@@ -110,395 +110,3 @@
     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,17 +1,8 @@
 from django import forms
-from django.db import transaction
 from django.urls import reverse
 
 from common.utils import safe_getattr
-from games.models import (
+from games.models import Device, Edition, Game, Platform, Purchase, Session
-    Device,
-    Game,
-    GameStatusChange,
-    Platform,
-    PlayEvent,
-    Purchase,
-    Session,
-)
 
 custom_date_widget = forms.DateInput(attrs={"type": "date"})
 custom_datetime_widget = forms.DateTimeInput(
@@ -20,37 +11,17 @@ custom_datetime_widget = forms.DateTimeInput(
 autofocus_input_widget = forms.TextInput(attrs={"autofocus": "autofocus"})
 
 
-class MultipleGameChoiceField(forms.ModelMultipleChoiceField):
-    def label_from_instance(self, obj) -> str:
-        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
-
-
-class SingleGameChoiceField(forms.ModelChoiceField):
-    def label_from_instance(self, obj) -> str:
-        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
-
-
 class SessionForm(forms.ModelForm):
-    game = SingleGameChoiceField(
+    # purchase = forms.ModelChoiceField(
-        queryset=Game.objects.order_by("sort_name"),
+    #     queryset=Purchase.objects.filter(date_refunded=None).order_by("edition__name")
+    # )
+    purchase = forms.ModelChoiceField(
+        queryset=Purchase.objects.all(),
         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,
@@ -58,27 +29,18 @@ class SessionForm(forms.ModelForm):
         }
         model = Session
         fields = [
-            "game",
+            "purchase",
             "timestamp_start",
             "timestamp_end",
             "duration_manual",
-            "emulated",
             "device",
             "note",
-            "mark_as_played",
         ]
 
-    def save(self, commit=True):
+
-        session = super().save(commit=False)
+class EditionChoiceField(forms.ModelMultipleChoiceField):
-        if self.cleaned_data.get("mark_as_played"):
+    def label_from_instance(self, obj) -> str:
-            game_instance = session.game
+        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
-            if game_instance.status == "u":
-                game_instance.status = "p"
-            if commit:
-                game_instance.save()
-        if commit:
-            session.save()
-        return session
 
 
 class IncludePlatformSelect(forms.SelectMultiple):
@@ -94,19 +56,19 @@ class PurchaseForm(forms.ModelForm):
         super().__init__(*args, **kwargs)
 
         # Automatically update related_purchase <select/>
-        # to only include purchases of the selected game.
+        # to only include purchases of the selected edition.
-        related_purchase_by_game_url = reverse("games:related_purchase_by_game")
+        related_purchase_by_edition_url = reverse("related_purchase_by_edition")
-        self.fields["games"].widget.attrs.update(
+        self.fields["editions"].widget.attrs.update(
             {
                 "hx-trigger": "load, click",
-                "hx-get": related_purchase_by_game_url,
+                "hx-get": related_purchase_by_edition_url,
                 "hx-target": "#id_related_purchase",
                 "hx-swap": "outerHTML",
             }
         )
 
-    games = MultipleGameChoiceField(
+    editions = EditionChoiceField(
-        queryset=Game.objects.order_by("sort_name"),
+        queryset=Edition.objects.order_by("sort_name"),
         widget=IncludePlatformSelect(attrs={"autoselect": "autoselect"}),
     )
     platform = forms.ModelChoiceField(queryset=Platform.objects.order_by("name"))
@@ -115,29 +77,21 @@ class PurchaseForm(forms.ModelForm):
         required=False,
     )
 
-    price_currency = forms.CharField(
-        widget=forms.TextInput(
-            attrs={
-                "x-mask": "aaa",
-                "placeholder": "CZK",
-                "x-data": "",
-                "class": "uppercase",
-            }
-        ),
-        label="Currency",
-    )
-
     class Meta:
         widgets = {
             "date_purchased": custom_date_widget,
             "date_refunded": custom_date_widget,
+            "date_finished": custom_date_widget,
+            "date_dropped": custom_date_widget,
         }
         model = Purchase
         fields = [
-            "games",
+            "editions",
             "platform",
             "date_purchased",
             "date_refunded",
+            "date_finished",
+            "date_dropped",
             "infinite",
             "price",
             "price_currency",
@@ -184,23 +138,24 @@ class GameModelChoiceField(forms.ModelChoiceField):
         return obj.sort_name
 
 
-class GameForm(forms.ModelForm):
+class EditionForm(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", "sort_name", "platform", "year_released", "wikidata"]
+
+
+class GameForm(forms.ModelForm):
     class Meta:
         model = Game
-        fields = [
+        fields = ["name", "sort_name", "year_released", "wikidata"]
-            "name",
-            "sort_name",
-            "platform",
-            "original_year_released",
-            "year_released",
-            "status",
-            "mastered",
-            "wikidata",
-        ]
         widgets = {"name": autofocus_input_widget}
 
 
@@ -220,48 +175,3 @@ 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/graphql/mutations/__init__.py

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

games/graphql/mutations/game.py

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

games/graphql/queries/__init__.py

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

games/graphql/queries/device.py

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

games/graphql/queries/edition.py

@@ -0,0 +1,11 @@
+import graphene
+
+from games.graphql.types import Edition
+from games.models import Game as EditionModel
+
+
+class Query(graphene.ObjectType):
+    editions = graphene.List(Edition)
+
+    def resolve_editions(self, info, **kwargs):
+        return EditionModel.objects.all()

games/graphql/queries/game.py

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

games/graphql/queries/platform.py

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

games/graphql/queries/purchase.py

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

games/graphql/queries/session.py

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

games/graphql/types.py

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

games/htmx_middleware.py

@@ -1,64 +0,0 @@
-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/migrations/0001_initial.py

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

games/migrations/0002_alter_session_duration_manual.py

@@ -0,0 +1,22 @@
+# 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

@@ -1,18 +0,0 @@
-# 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

@@ -0,0 +1,23 @@
+# 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

@@ -1,18 +0,0 @@
-# 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

@@ -0,0 +1,22 @@
+# 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

@@ -1,28 +0,0 @@
-# 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

@@ -0,0 +1,35 @@
+# 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

@@ -1,38 +0,0 @@
-# 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

@@ -1,59 +0,0 @@
-# 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

@@ -0,0 +1,35 @@
+# 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

@@ -0,0 +1,35 @@
+# 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

@@ -1,18 +0,0 @@
-# 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

@@ -0,0 +1,41 @@
+# 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

@@ -1,190 +0,0 @@
-# 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

@@ -0,0 +1,34 @@
+# 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

@@ -1,21 +0,0 @@
-# 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

@@ -0,0 +1,21 @@
+# 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

@@ -1,17 +0,0 @@
-# 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

@@ -1,20 +0,0 @@
-# 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

@@ -0,0 +1,18 @@
+# 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

@@ -1,32 +0,0 @@
-# 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

@@ -0,0 +1,23 @@
+# 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

@@ -1,35 +0,0 @@
-# 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

@@ -0,0 +1,31 @@
+# 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

@@ -0,0 +1,52 @@
+# 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

@@ -1,19 +0,0 @@
-# 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

@@ -1,39 +0,0 @@
-# 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

@@ -0,0 +1,23 @@
+# 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_alter_edition_platform_alter_edition_year_released_and_more.py

@@ -0,0 +1,51 @@
+# 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

@@ -0,0 +1,141 @@
+# 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

@@ -0,0 +1,41 @@
+# 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

@@ -0,0 +1,34 @@
+# 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

@@ -0,0 +1,17 @@
+# 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

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,21 @@
+# 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

@@ -0,0 +1,39 @@
+# 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

@@ -0,0 +1,39 @@
+# 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

@@ -0,0 +1,27 @@
+# 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

@@ -0,0 +1,25 @@
+# Generated by Django 4.1.5 on 2023-11-14 08:41
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+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

@@ -0,0 +1,26 @@
+# 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

@@ -0,0 +1,26 @@
+# 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

@@ -0,0 +1,18 @@
+# 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

@@ -0,0 +1,44 @@
+# 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

@@ -0,0 +1,52 @@
+# 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/migrations/0033_alter_edition_unique_together.py

@@ -0,0 +1,17 @@
+# Generated by Django 4.2.7 on 2023-11-28 13:43
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("games", "0032_alter_session_options_session_modified_at_and_more"),
+    ]
+
+    operations = [
+        migrations.AlterUniqueTogether(
+            name="edition",
+            unique_together={("name", "platform", "year_released")},
+        ),
+    ]

games/migrations/0034_purchase_date_dropped_purchase_infinite.py

@@ -0,0 +1,23 @@
+# Generated by Django 4.2.7 on 2024-01-03 21:27
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("games", "0033_alter_edition_unique_together"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="purchase",
+            name="date_dropped",
+            field=models.DateField(blank=True, null=True),
+        ),
+        migrations.AddField(
+            model_name="purchase",
+            name="infinite",
+            field=models.BooleanField(default=False),
+        ),
+    ]

games/migrations/0035_alter_session_device.py

@@ -0,0 +1,25 @@
+# Generated by Django 5.1 on 2024-08-11 15:50
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("games", "0034_purchase_date_dropped_purchase_infinite"),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name="session",
+            name="device",
+            field=models.ForeignKey(
+                blank=True,
+                default=None,
+                null=True,
+                on_delete=django.db.models.deletion.SET_DEFAULT,
+                to="games.device",
+            ),
+        ),
+    ]

games/migrations/0036_alter_edition_platform.py

@@ -0,0 +1,19 @@
+# Generated by Django 5.1 on 2024-08-11 16:48
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0035_alter_session_device'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='edition',
+            name='platform',
+            field=models.ForeignKey(blank=True, default=None, null=True, on_delete=django.db.models.deletion.SET_DEFAULT, to='games.platform'),
+        ),
+    ]

games/migrations/0037_platform_icon.py

@@ -0,0 +1,26 @@
+# Generated by Django 5.1.1 on 2024-09-14 07:05
+
+from django.db import migrations, models
+from django.utils.text import slugify
+
+
+def update_empty_icons(apps, schema_editor):
+    Platform = apps.get_model("games", "Platform")
+    for platform in Platform.objects.filter(icon=""):
+        platform.icon = slugify(platform.name)
+        platform.save()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0036_alter_edition_platform"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="platform",
+            name="icon",
+            field=models.SlugField(blank=True),
+        ),
+        migrations.RunPython(update_empty_icons),
+    ]

games/migrations/0038_alter_purchase_price.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.1 on 2024-10-04 09:23
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0037_platform_icon'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='purchase',
+            name='price',
+            field=models.FloatField(default=0),
+        ),
+    ]

games/migrations/0039_alter_device_type.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.2 on 2024-11-09 22:38
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0038_alter_purchase_price'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='device',
+            name='type',
+            field=models.CharField(choices=[('PC', 'PC'), ('Console', 'Console'), ('Handheld', 'Handheld'), ('Mobile', 'Mobile'), ('Single-board computer', 'Single-board computer'), ('Unknown', 'Unknown')], default='Unknown', max_length=255),
+        ),
+    ]

games/migrations/0040_migrate_device_types.py

@@ -0,0 +1,33 @@
+# Generated by Django 5.1.2 on 2024-11-09 22:39
+
+from django.db import migrations
+
+
+def update_device_types(apps, schema_editor):
+    Device = apps.get_model("games", "Device")
+
+    # Mapping of short names to long names
+    type_map = {
+        "pc": "PC",
+        "co": "Console",
+        "ha": "Handheld",
+        "mo": "Mobile",
+        "sbc": "Single-board computer",
+        "un": "Unknown",
+    }
+
+    # Loop through all devices and update the type field
+    for device in Device.objects.all():
+        if device.type in type_map:
+            device.type = type_map[device.type]
+            device.save()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0039_alter_device_type"),
+    ]
+
+    operations = [
+        migrations.RunPython(update_device_types),
+    ]

games/migrations/0041_purchase_converted_currency_purchase_converted_price_and_more.py

@@ -0,0 +1,36 @@
+# Generated by Django 5.1.3 on 2024-11-10 15:14
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0040_migrate_device_types'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='purchase',
+            name='converted_currency',
+            field=models.CharField(max_length=3, null=True),
+        ),
+        migrations.AddField(
+            model_name='purchase',
+            name='converted_price',
+            field=models.FloatField(null=True),
+        ),
+        migrations.CreateModel(
+            name='ExchangeRate',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('currency_from', models.CharField(max_length=255)),
+                ('currency_to', models.CharField(max_length=255)),
+                ('year', models.PositiveIntegerField()),
+                ('rate', models.FloatField()),
+            ],
+            options={
+                'unique_together': {('currency_from', 'currency_to', 'year')},
+            },
+        ),
+    ]

games/migrations/0042_purchase_editions_temp.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.3 on 2025-01-07 20:14
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0041_purchase_converted_currency_purchase_converted_price_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='purchase',
+            name='editions_temp',
+            field=models.ManyToManyField(blank=True, related_name='temp_purchases', to='games.edition'),
+        ),
+    ]

games/migrations/0043_auto_20250107_2117.py

@@ -0,0 +1,23 @@
+# Generated by Django 5.1.3 on 2025-01-07 20:17
+
+from django.db import migrations
+
+
+def migrate_edition_to_editions_temp(apps, schema_editor):
+    Purchase = apps.get_model("games", "Purchase")
+    for purchase in Purchase.objects.all():
+        if purchase.edition:
+            purchase.editions_temp.add(purchase.edition)
+            purchase.save()
+        else:
+            print(f"No edition found for Purchase {purchase.id}")
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0042_purchase_editions_temp"),
+    ]
+
+    operations = [
+        migrations.RunPython(migrate_edition_to_editions_temp),
+    ]

games/migrations/0044_auto_20250107_2132.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.3 on 2025-01-07 20:32
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0043_auto_20250107_2117"),
+    ]
+
+    operations = [
+        migrations.RemoveField(model_name="purchase", name="edition"),
+        migrations.RenameField(
+            model_name="purchase",
+            old_name="editions_temp",
+            new_name="editions",
+        ),
+    ]

games/migrations/0045_alter_purchase_editions.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.1.3 on 2025-01-07 20:37
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('games', '0044_auto_20250107_2132'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='purchase',
+            name='editions',
+            field=models.ManyToManyField(blank=True, related_name='purchases', to='games.edition'),
+        ),
+    ]

games/migrations/0046_game_platform_alter_game_unique_together.py

@@ -0,0 +1,28 @@
+# Generated by Django 5.1.3 on 2025-01-08 20:06
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0045_alter_purchase_editions"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="game",
+            name="platform",
+            field=models.ForeignKey(
+                blank=True,
+                default=None,
+                null=True,
+                on_delete=django.db.models.deletion.SET_DEFAULT,
+                to="games.platform",
+            ),
+        ),
+        migrations.AlterUniqueTogether(
+            name="game",
+            unique_together={("name", "platform", "year_released")},
+        ),
+    ]

games/migrations/0047_auto_20250119_2129.py

@@ -0,0 +1,61 @@
+# Generated by Django 5.1.3 on 2025-01-19 20:29
+
+from django.db import connection, migrations, models
+
+
+def recreate_games(apps, schema_editor):
+    Edition = apps.get_model("games", "Edition")
+    Game = apps.get_model("games", "Game")
+    Purchase = apps.get_model("games", "Purchase")
+
+    with connection.cursor() as cursor:
+        print("Create table games_gametemp")
+        cursor.execute(
+            "CREATE TABLE games_gametemp AS SELECT * FROM games_game WHERE 1=0;"
+        )
+
+        for edition in Edition.objects.all():
+            print(f"Re-create edition with ID {edition.id}")
+            cursor.execute(
+                """
+                INSERT INTO games_gametemp (
+                    id, name, sort_name, year_released, platform_id, wikidata, created_at
+                )
+                VALUES (%s, %s, %s, %s, %s, %s, %s)
+                """,
+                [
+                    edition.id,  # Reuse the Edition ID
+                    edition.name,
+                    edition.sort_name,
+                    edition.year_released,
+                    edition.platform_id,
+                    Game.objects.get(id=edition.game.id).wikidata,
+                    edition.created_at,
+                ],
+            )
+        print("Turn foreign keys off")
+        cursor.execute("PRAGMA foreign_keys = OFF;")
+        print("Drop table games_game")
+        cursor.execute("DROP TABLE games_game;")
+        print("Drop table games_edition")
+        cursor.execute("DROP TABLE games_edition;")
+        print("Rename table games_gametemp to games_game")
+        # cursor.execute("ALTER TABLE games_gametemp RENAME TO games_game;")
+        cursor.execute("CREATE TABLE games_game AS SELECT * FROM games_gametemp;")
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("games", "0046_game_platform_alter_game_unique_together"),
+    ]
+
+    operations = [
+        migrations.RunPython(recreate_games),
+        migrations.AlterField(
+            model_name="purchase",
+            name="editions",
+            field=models.ManyToManyField(
+                blank=True, related_name="purchases", to="games.game"
+            ),
+        ),
+    ]

games/models.py

@@ -1,104 +1,17 @@
-import logging
 from datetime import timedelta
 
-import requests
 from django.core.exceptions import ValidationError
 from django.db import models
-from django.db.models import F, Q, Sum
+from django.db.models import F, Sum
-from django.db.models.expressions import RawSQL
+from django.template.defaultfilters import slugify
-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, blank=True, default="")
-    year_released = models.IntegerField(null=True, blank=True, default=None)
-    original_year_released = models.IntegerField(null=True, blank=True, default=None)
-    wikidata = models.CharField(max_length=50, blank=True, default="")
-    platform = models.ForeignKey(
-        "Platform", on_delete=models.SET_DEFAULT, null=True, blank=True, default=None
-    )
-
-    playtime = models.DurationField(blank=True, editable=False, default=timedelta(0))
-
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-    class Status(models.TextChoices):
-        UNPLAYED = (
-            "u",
-            "Unplayed",
-        )
-        PLAYED = (
-            "p",
-            "Played",
-        )
-        FINISHED = (
-            "f",
-            "Finished",
-        )
-        RETIRED = (
-            "r",
-            "Retired",
-        )
-        ABANDONED = (
-            "a",
-            "Abandoned",
-        )
-
-    status = models.CharField(max_length=1, choices=Status, default=Status.UNPLAYED)
-    mastered = models.BooleanField(default=False)
-
-    session_average: float | int | timedelta | None
-    session_count: int | None
-
-    def __str__(self):
-        return self.name
-
-    def finished(self):
-        return (self.status == self.Status.FINISHED 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="")
+    group = models.CharField(max_length=255, null=True, blank=True, default=None)
     icon = models.SlugField(blank=True)
     created_at = models.DateTimeField(auto_now_add=True)
 
@@ -111,6 +24,55 @@ class Platform(models.Model):
         super().save(*args, **kwargs)
 
 
+def get_sentinel_platform():
+    return Platform.objects.get_or_create(
+        name="Unspecified", icon="unspecified", group="Unspecified"
+    )[0]
+
+
+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)
+    year_released = models.IntegerField(null=True, blank=True, default=None)
+    platform = models.ForeignKey(
+        Platform, on_delete=models.SET_DEFAULT, null=True, blank=True, default=None
+    )
+    wikidata = models.CharField(max_length=50, null=True, blank=True, default=None)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    session_average: float | int | timedelta | None
+    session_count: int | None
+
+    def __str__(self):
+        return self.name
+
+
+class Edition(models.Model):
+    class Meta:
+        unique_together = [["name", "platform", "year_released"]]
+
+    game = models.ForeignKey(Game, on_delete=models.CASCADE)
+    name = models.CharField(max_length=255)
+    sort_name = models.CharField(max_length=255, null=True, blank=True, default=None)
+    platform = models.ForeignKey(
+        Platform, on_delete=models.SET_DEFAULT, null=True, blank=True, default=None
+    )
+    year_released = models.IntegerField(null=True, blank=True, default=None)
+    wikidata = models.CharField(max_length=50, null=True, blank=True, default=None)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    def __str__(self):
+        return self.sort_name
+
+    def save(self, *args, **kwargs):
+        if self.platform is None:
+            self.platform = get_sentinel_platform()
+        super().save(*args, **kwargs)
+
+
 class PurchaseQueryset(models.QuerySet):
     def refunded(self):
         return self.filter(date_refunded__isnull=False)
@@ -118,22 +80,12 @@ 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"
@@ -167,89 +119,54 @@ class Purchase(models.Model):
 
     objects = PurchaseQueryset().as_manager()
 
-    games = models.ManyToManyField(Game, related_name="purchases")
+    editions = models.ManyToManyField(Game, related_name="purchases", blank=True)
-
     platform = models.ForeignKey(
         Platform, on_delete=models.CASCADE, default=None, null=True, blank=True
     )
-    date_purchased = models.DateField(verbose_name="Purchased")
+    date_purchased = models.DateField()
-    date_refunded = models.DateField(blank=True, null=True, verbose_name="Refunded")
+    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(max_length=3, default="USD")
     converted_price = models.FloatField(null=True)
-    converted_currency = models.CharField(max_length=3, blank=True, default="")
+    converted_currency = models.CharField(max_length=3, null=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, blank=True, default="")
+    name = models.CharField(max_length=255, default="", null=True, blank=True)
     related_purchase = models.ForeignKey(
         "self",
         on_delete=models.SET_NULL,
         default=None,
         null=True,
+        blank=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):
+    def first_edition(self):
-        return (
+        return self.editions.first()
-            f"{floatformat(self.converted_price, 0)} {self.converted_currency}"
-            if self.converted_price
-            else None
-        )
-
-    @property
-    def has_one_item(self):
-        return self.games.count() == 1
-
-    @property
-    def standardized_name(self):
-        return self.name or self.first_game.name
-
-    @property
-    def first_game(self):
-        return self.games.first()
 
     def __str__(self):
-        return self.standardized_name
-
-    @property
-    def full_name(self):
         additional_info = [
-            str(item)
+            self.get_type_display() if self.type != Purchase.GAME else "",
-            for item in [
+            (
-                f"{self.num_purchases} game{pluralize(self.num_purchases)}",
+                f"{self.first_edition.platform} version on {self.platform}"
-                self.date_purchased,
+                if self.platform != self.first_edition.platform
-                self.standardized_price,
+                else self.platform
+            ),
+            self.first_edition.year_released,
+            self.get_ownership_type_display(),
         ]
-            if item
+        return f"{self.first_edition} ({', '.join(filter(None, map(str, additional_info)))})"
-        ]
-        return f"{self.standardized_name} ({', '.join(additional_info)})"
 
     def is_game(self):
         return self.type == self.GAME
 
-    def price_or_currency_differ_from(self, purchase_to_compare):
-        return (
-            self.price != purchase_to_compare.price
-            or self.price_currency != purchase_to_compare.price_currency
-        )
-
-    def refund(self):
-        self.date_refunded = timezone.now()
-        self.save()
-
     def save(self, *args, **kwargs):
         if self.type != Purchase.GAME and not self.related_purchase:
             raise ValidationError(
@@ -259,15 +176,12 @@ class Purchase(models.Model):
             # Retrieve the existing instance from the database
             existing_purchase = Purchase.objects.get(pk=self.pk)
             # If price has changed, reset converted fields
-            if existing_purchase.price_or_currency_differ_from(self):
+            if (
-                from games.tasks import currency_to
+                existing_purchase.price != self.price
-
+                or existing_purchase.price_currency != self.price_currency
-                exchange_rate = get_or_create_rate(
+            ):
-                    self.price_currency, currency_to, self.date_purchased.year
+                self.converted_price = None
-                )
+                self.converted_currency = None
-                if exchange_rate:
-                    self.converted_price = floatformat(self.price * exchange_rate, 0)
-                    self.converted_currency = currency_to
         super().save(*args, **kwargs)
 
 
@@ -299,30 +213,11 @@ class Session(models.Model):
     class Meta:
         get_latest_by = "timestamp_start"
 
-    game = models.ForeignKey(
+    purchase = models.ForeignKey(Purchase, on_delete=models.CASCADE)
-        Game,
+    timestamp_start = models.DateTimeField()
-        on_delete=models.CASCADE,
+    timestamp_end = models.DateTimeField(blank=True, null=True)
-        null=True,
+    duration_manual = models.DurationField(blank=True, null=True, default=timedelta(0))
-        default=None,
+    duration_calculated = models.DurationField(blank=True, null=True)
-        related_name="sessions",
-    )
-    timestamp_start = models.DateTimeField(verbose_name="Start")
-    timestamp_end = models.DateTimeField(blank=True, null=True, verbose_name="End")
-    duration_manual = models.DurationField(
-        blank=True, null=True, default=timedelta(0), verbose_name="Manual duration"
-    )
-    duration_calculated = GeneratedField(
-        expression=Coalesce(F("timestamp_end") - F("timestamp_start"), 0),
-        output_field=models.DurationField(),
-        db_persist=True,
-        editable=False,
-    )
-    duration_total = GeneratedField(
-        expression=F("duration_calculated") + F("duration_manual"),
-        output_field=models.DurationField(),
-        db_persist=True,
-        editable=False,
-    )
     device = models.ForeignKey(
         "Device",
         on_delete=models.SET_DEFAULT,
@@ -330,17 +225,15 @@ class Session(models.Model):
         blank=True,
         default=None,
     )
-    note = models.TextField(blank=True, default="")
+    note = models.TextField(blank=True, null=True)
-    emulated = models.BooleanField(default=False)
-
     created_at = models.DateTimeField(auto_now_add=True)
     modified_at = models.DateTimeField(auto_now=True)
 
     objects = SessionQuerySet.as_manager()
 
     def __str__(self):
-        mark = "*" if self.is_manual() else ""
+        mark = ", manual" if self.is_manual() else ""
-        return f"{str(self.game)} {str(self.timestamp_start.date())} ({self.duration_formatted()}{mark})"
+        return f"{str(self.purchase)} {str(self.timestamp_start.date())} ({self.duration_formatted()}{mark})"
 
     def finish_now(self):
         self.timestamp_end = timezone.now()
@@ -348,18 +241,32 @@ class Session(models.Model):
     def start_now():
         self.timestamp_start = timezone.now()
 
-    def duration_formatted(self) -> str:
+    def duration_seconds(self) -> timedelta:
-        result = format_duration(self.duration_total, "%02.1H")
+        manual = timedelta(0)
-        return result
+        calculated = timedelta(0)
+        if self.is_manual() and isinstance(self.duration_manual, timedelta):
+            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_with_mark(self) -> str:
+    def duration_formatted(self) -> str:
-        mark = "*" if self.is_manual() else ""
+        result = format_duration(self.duration_seconds(), "%02.0H:%02.0m")
-        return f"{self.duration_formatted()}{mark}"
+        return result
 
     def is_manual(self) -> bool:
         return not self.duration_manual == timedelta(0)
 
+    @property
+    def duration_sum(self) -> str:
+        return Session.objects.all().total_duration_formatted()
+
     def save(self, *args, **kwargs) -> None:
+        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 isinstance(self.duration_manual, timedelta):
             self.duration_manual = timedelta(0)
 
@@ -405,97 +312,3 @@ class ExchangeRate(models.Model):
 
     def __str__(self):
         return f"{self.currency_from}/{self.currency_to} - {self.rate} ({self.year})"
-
-
-def get_or_create_rate(currency_from: str, currency_to: str, year: int) -> float | None:
-    exchange_rate = None
-    result = ExchangeRate.objects.filter(
-        currency_from=currency_from, currency_to=currency_to, year=year
-    )
-    if result:
-        exchange_rate = result[0].rate
-    else:
-        try:
-            # this API endpoint only accepts lowercase currency string
-            response = requests.get(
-                f"https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@{year}-01-01/v1/currencies/{currency_from.lower()}.json"
-            )
-            response.raise_for_status()
-            data = response.json()
-            currency_from_data = data.get(currency_from.lower())
-            rate = currency_from_data.get(currency_to.lower())
-
-            if rate:
-                logger.info(f"[convert_prices]: Got {rate}, saving...")
-                exchange_rate = ExchangeRate.objects.create(
-                    currency_from=currency_from,
-                    currency_to=currency_to,
-                    year=year,
-                    rate=floatformat(rate, 2),
-                )
-                exchange_rate = exchange_rate.rate
-            else:
-                logger.info("[convert_prices]: Could not get an exchange rate.")
-        except requests.RequestException as e:
-            logger.info(
-                f"[convert_prices]: Failed to fetch exchange rate for {currency_from}->{currency_to} in {year}: {e}"
-            )
-    return exchange_rate
-
-
-class PlayEvent(models.Model):
-    game = models.ForeignKey(Game, related_name="playevents", on_delete=models.CASCADE)
-    started = models.DateField(null=True, blank=True)
-    ended = models.DateField(null=True, blank=True)
-    days_to_finish = GeneratedField(
-        # special cases:
-        # missing ended, started, or both = 0
-        # same day = 1 day to finish
-        expression=RawSQL(
-            """
-            COALESCE(
-                CASE 
-                    WHEN date(ended) = date(started) THEN 1
-                    ELSE julianday(ended) - julianday(started)
-                END, 0
-            )
-            """,
-            [],
-        ),
-        output_field=models.IntegerField(),
-        db_persist=True,
-        editable=False,
-        blank=True,
-    )
-    note = models.CharField(max_length=255, blank=True, default="")
-
-    created_at = models.DateTimeField(auto_now_add=True)
-    updated_at = models.DateTimeField(auto_now=True)
-
-
-# class PlayMarker(models.Model):
-#     game = models.ForeignKey(Game, related_name="markers", on_delete=models.CASCADE)
-#     played_since = models.DurationField()
-#     played_total = models.DurationField()
-#     note = models.CharField(max_length=255)
-
-
-class GameStatusChange(models.Model):
-    """
-    Tracks changes to the status of a Game.
-    """
-
-    game = models.ForeignKey(
-        Game, on_delete=models.CASCADE, related_name="status_changes"
-    )
-    old_status = models.CharField(
-        max_length=1, choices=Game.Status.choices, blank=True, null=True
-    )
-    new_status = models.CharField(max_length=1, choices=Game.Status.choices)
-    timestamp = models.DateTimeField(null=True)
-
-    def __str__(self):
-        return f"{self.game.name}: {self.old_status or 'None'} -> {self.new_status} at {self.timestamp}"
-
-    class Meta:
-        ordering = ["-timestamp"]

games/schema.py

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

games/signals.py

@@ -1,89 +0,0 @@
-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(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")

games/static/js/add_purchase.js

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

games/static/js/htmx-redirect-toast.js

@@ -1,37 +0,0 @@
-(function() {
-  htmx.defineExtension("hx-redirect-toast", {
-    isInlineSwap: function(swapStyle) {
-      return swapStyle === "hx-redirect-toast";
-    },
-    handleSwap: function(swapStyle, target, fragment, settleInfo, htmxConfig) {
-      var xhr = htmxConfig.xhr;
-      var hxRedirect = xhr.getResponseHeader("HX-Redirect");
-      var hxTrigger = xhr.getResponseHeader("HX-Trigger");
-
-      // Redirect immediately (toast will be shown on the new page)
-      if (hxRedirect) {
-        window.location.href = hxRedirect;
-      }
-
-      // Only dispatch HX-Trigger events for toasts when not redirecting
-      if (!hxRedirect && hxTrigger) {
-        var triggers = JSON.parse(hxTrigger);
-        var events = Array.isArray(triggers) ? triggers : [triggers];
-        events.forEach(function(triggerObj) {
-          Object.entries(triggerObj).forEach(function(entry) {
-            var name = entry[0];
-            var detail = entry[1];
-            try { detail = JSON.parse(detail); } catch(e) {}
-            target.dispatchEvent(new CustomEvent(name, {
-              detail: detail,
-              bubbles: true,
-              cancelable: true
-            }));
-          });
-        });
-      }
-      // Return null to prevent any DOM swap
-      return null;
-    }
-  });
-})();

games/static/js/toast.js

@@ -1,173 +0,0 @@
-document.addEventListener("alpine:init", () => {
-  let idCounter = 0;
-
-  console.log("[toast] Alpine available:", typeof Alpine !== "undefined");
-
-  Alpine.store("toasts", {
-    toasts: [],
-
-    addToast(message, type) {
-      console.log("[toast] addToast called:", { message, type });
-      if (!type) type = "info";
-      const validTypes = ["success", "error", "info", "warning", "debug"];
-      if (!validTypes.includes(type)) type = "info";
-
-      if (this.toasts.length >= 3) {
-        console.log("[toast] max 3 toasts reached, removing oldest");
-        this.toasts.shift();
-      }
-
-      const id = ++idCounter;
-      console.log("[toast] toast added, count:", this.toasts.length);
-      this.toasts.push({ id, message, type, visible: true, timer: null, pausedAt: null });
-
-      if (type !== "error") {
-        const toast = this.toasts[this.toasts.length - 1];
-        const autoDismissDelay = type === "debug" ? 3000 : 5000;
-        toast.timer = setTimeout(() => {
-          console.log("[toast] auto-dismiss after " + (autoDismissDelay / 1000) + "s");
-          this.dismissToast(id);
-        }, autoDismissDelay);
-      }
-    },
-
-    dismissToast(id) {
-      console.log("[toast] dismissToast for id:", id);
-      const idx = this.toasts.findIndex((t) => t.id === id);
-      if (idx === -1) { console.log("[toast] toast not found"); return; }
-
-      const toast = this.toasts[idx];
-      if (toast.timer) clearTimeout(toast.timer);
-      toast.visible = false;
-
-      setTimeout(() => {
-        this.toasts = this.toasts.filter((t) => t.id !== id);
-        console.log("[toast] after dismiss, count:", this.toasts.length);
-      }, 300);
-    },
-
-    clearToastTimer(id) {
-      const toast = this.toasts.find((t) => t.id === id);
-      if (toast?.timer) {
-        console.log("[toast] pause timer for toast id:", id);
-        clearTimeout(toast.timer);
-        toast.timer = null;
-        toast.pausedAt = Date.now();
-      }
-    },
-
-    resumeToastTimer(id, duration) {
-      const toast = this.toasts.find((t) => t.id === id);
-      if (toast?.pausedAt && toast.timer === null) {
-        console.log("[toast] resume timer for toast id:", id);
-        toast.timer = setTimeout(() => {
-          this.dismissToast(id);
-        }, duration);
-        toast.pausedAt = null;
-      }
-    },
-  });
-
-  Alpine.data("toastStore", () => ({
-    init() {
-      console.log("[toast] toastStore.init running");
-      console.log("[toast] Alpine store toasts:", Alpine.store("toasts").toasts);
-
-      window.addEventListener("show-toast", (e) => {
-        console.log("[toast] show-toast event received:", e.detail);
-        if (Array.isArray(e.detail)) {
-          e.detail.forEach((msg) => {
-            Alpine.store("toasts").addToast(msg.message, msg.type);
-          });
-        } else {
-          Alpine.store("toasts").addToast(e.detail.message, e.detail.type);
-        }
-      });
-
-      try {
-        const script = document.getElementById("django-messages");
-        if (script) {
-          const msgs = JSON.parse(
-            script.textContent || script.innerText || "[]"
-          );
-          console.log("[toast] django-messages script found:", msgs);
-          if (Array.isArray(msgs)) {
-            msgs.forEach((msg) => {
-              console.log("[toast] loading django-message:", msg);
-              Alpine.store("toasts").addToast(msg.message, msg.type || "info");
-            });
-          }
-        }
-      } catch (e) {
-        console.error("[toast] localStorage restore failed:", e);
-        // ignore parse errors
-      }
-    },
-
-    addToast(message, type) {
-      console.log("[toast] toastStore.addToast delegating:", { message, type });
-      Alpine.store("toasts").addToast(message, type);
-    },
-
-    dismissToast(id) {
-      console.log("[toast] toastStore.dismissToast delegating:", id);
-      Alpine.store("toasts").dismissToast(id);
-    },
-  }));
-});
-
-function toast(message, type) {
-  console.log("[toast] toast() called:", { message, type });
-  const evt = new CustomEvent("show-toast", {
-    detail: { message, type },
-    bubbles: true,
-  });
-  document.dispatchEvent(evt);
-  console.log("[toast] CustomEvent dispatched, type:", evt.type);
-}
-window.toast = toast;
-
-/**
- * Wrapper around fetch() that dispatches HTMX HX-Trigger events.
- * Use this for any fetch() call that expects HX-Trigger headers
- * (e.g., to show toasts via the HTMX middleware).
- *
- * @todo Migrate these call sites to hx-post + hx-on::after-request
- * for HTMX-native toast handling.
- */
-window.fetchWithHtmxTriggers = function fetchWithHtmxTriggers(url, options = {}) {
-  console.log("[fetchWithHtmxTriggers] fetching:", url);
-  return fetch(url, options).then(async (response) => {
-    console.log("[fetchWithHtmxTriggers] response status:", response.status);
-    const htmxTrigger = response.headers.get("HX-Trigger");
-    console.log("[fetchWithHtmxTriggers] HX-Trigger header:", htmxTrigger);
-    if (htmxTrigger) {
-      let triggers;
-      try {
-        triggers = JSON.parse(htmxTrigger);
-        console.log("[fetchWithHtmxTriggers] parsed triggers:", triggers);
-      } catch {
-        console.warn("[fetchWithHtmxTriggers] failed to parse HX-Trigger JSON");
-        return response;
-      }
-      // Handle both single object and array of events
-      const events = Array.isArray(triggers) ? triggers : [triggers];
-      events.forEach((triggerObj) => {
-        Object.entries(triggerObj).forEach(([name, detail]) => {
-          console.log("[fetchWithHtmxTriggers] dispatching event:", name, detail);
-          let parsedDetail = detail;
-          try {
-            parsedDetail = JSON.parse(detail);
-          } catch {
-            // keep as string
-          }
-          document.dispatchEvent(new CustomEvent(name, {
-            detail: parsedDetail,
-            bubbles: true,
-          }));
-        });
-      });
-    }
-    return response;
-  });
-};

games/static/js/utils.js

@@ -43,7 +43,6 @@ function syncSelectInputUntilChanged(syncData, parentSelector = document) {
         const targetElement = document.querySelector(syncItem.target);
 
         if (targetElement && valueToSync !== null) {
-          console.log(`Changing value of ${syncItem.target} to ${valueToSync}`)
           targetElement[syncItem.target_value] = valueToSync;
         }
       }
@@ -185,17 +184,13 @@ function disableElementsWhenValueNotEqual(
 function disableElementsWhenTrue(targetSelect, targetValue, elementList) {
   return conditionalElementHandler([
     () => {
-      console.log(`${disableElementsWhenTrue.name}: triggered on ${targetSelect}`)
-      console.log(`Value of ${targetSelect} is ${targetValue}: ${getEl(targetSelect).value == targetValue}`)
       return getEl(targetSelect).value == targetValue;
     },
     elementList,
     (el) => {
-      console.log(`${disableElementsWhenTrue.name}: disabling ${el.id}`)
       el.disabled = "disabled";
     },
     (el) => {
-      console.log(`${disableElementsWhenTrue.name}: enabling ${el.id}`)
       el.disabled = "";
     },
   ]);