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

Prevents actually finding any new prices

.devcontainer/devcontainer.json

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

.editorconfig

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

.pre-commit-config.yaml

@@ -1,20 +0,0 @@
-repos:
-# disable due to incomaptible formatting between
-# black and ruff
-# TODO: replace with ruff when it works on NixOS
-# -   repo: https://github.com/psf/black
-#     rev: 24.8.0
-#     hooks:
-#     -   id: black
-- repo: https://github.com/pycqa/isort
-  rev: 5.13.2
-  hooks:
-    - id: isort
-      name: isort (python)
-- repo: https://github.com/Riverside-Healthcare/djLint
-  rev: v1.34.0
-  hooks:
-    - id: djlint-reformat-django
-      args: ["--ignore", "H011"]
-    - id: djlint-django
-      args: ["--ignore", "H011"]

.vscode/launch.json

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

CHANGELOG.md

@@ -7,6 +7,9 @@
 * Allow deleting purchases
 * Add all-time stats
 * Manage purchases
+* Automatically convert purchase prices
+* Add emulated property to sessions
+* Add today's and last 7 days playtime stats to navbar
 
 ## Improved
 * mark refunded purchases red on game overview

common/components.py

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

common/input.css

@@ -44,9 +44,9 @@
   transition: all 0.2s ease-out;
 } */
 
-form label {
+/* form label {
   @apply dark:text-slate-400;
-}
+} */
 
 .responsive-table {
   @apply dark:text-white mx-auto table-fixed;
@@ -90,37 +90,37 @@ form label {
   }
 }
 
-form input,
+/* form input,
 select,
 textarea {
   @apply dark:border dark:border-slate-900 dark:bg-slate-500 dark:text-slate-100;
-}
+} */
 
 form input:disabled,
 select:disabled,
 textarea:disabled {
-  @apply dark:bg-slate-700 dark:text-slate-400;
+  @apply dark:bg-slate-800 dark:text-slate-500 cursor-not-allowed;
 }
 
 .errorlist {
   @apply mt-4 mb-1 pl-3 py-2 bg-red-600 text-slate-200 w-[300px];
 }
 
-@media screen and (min-width: 768px) {
+/* @media screen and (min-width: 768px) {
   form input,
   select,
   textarea {
     width: 300px;
   }
-}
+} */
 
-@media screen and (max-width: 768px) {
+/* @media screen and (max-width: 768px) {
   form input,
   select,
   textarea {
     width: 150px;
   }
-}
+} */
 
 #button-container button {
   @apply mx-1;
@@ -169,3 +169,27 @@ textarea:disabled {
     
   }  
 } */
+
+label {
+  @apply dark:text-slate-500;
+}
+
+[type="text"], [type="password"], [type="datetime-local"], [type="datetime"], [type="date"], [type="number"], select, textarea {
+  @apply dark:bg-slate-600 dark:text-slate-300;
+}
+
+[type="submit"] {
+  @apply dark:text-white font-bold dark:bg-blue-600 px-4 py-2;
+}
+
+form div label {
+  @apply dark:text-white;
+}
+
+form div {
+  @apply flex flex-col;
+}
+
+div [type="submit"] {
+  @apply mt-3;
+}

common/time.py

@@ -13,7 +13,7 @@ durationformat_manual: str = "%H hours"
 
 
 def _safe_timedelta(duration: timedelta | int | None):
-    if duration == None:
+    if duration is None:
         return timedelta(0)
     elif isinstance(duration, int):
         return timedelta(seconds=duration)
@@ -163,3 +163,7 @@ def streak_bruteforce(datelist: list[date]) -> dict[str, int | tuple[date, date]
         else:
             increment_streak()
     return {"days": highest_streak, "dates": highest_streak_daterange}
+
+
+def available_stats_year_range():
+    return range(datetime.now().year, 1999, -1)

common/utils.py

@@ -1,98 +1,13 @@
+import operator
+from dataclasses import dataclass
 from datetime import date
-from random import choices
+from functools import reduce, wraps
-from string import ascii_lowercase
+from typing import Any, Callable, Generator, Literal, TypeVar
-from typing import Any, Callable, Generator, TypeVar
+from urllib.parse import urlencode
 
-from django.template.loader import render_to_string
+from django.db.models import Q
-from django.urls import NoReverseMatch, reverse
+from django.http import HttpRequest
-from django.utils.safestring import mark_safe
+from django.shortcuts import redirect
-
-
-def Popover(
-    wrapped_content: str,
-    popover_content: str = "",
-) -> str:
-    id = randomid()
-    if popover_content == "":
-        popover_content = wrapped_content
-    content = f"<span data-popover-target={id}>{wrapped_content}</span>"
-    result = mark_safe(
-        str(content)
-        + render_to_string(
-            "cotton/popover.html",
-            {
-                "id": id,
-                "slot": popover_content,
-            },
-        )
-    )
-    return result
-
-
-HTMLAttribute = tuple[str, str]
-HTMLTag = str
-
-
-def Component(
-    attributes: list[HTMLAttribute] = [],
-    children: list[HTMLTag] | HTMLTag = [],
-    template: str = "",
-    tag_name: str = "",
-) -> HTMLTag:
-    if not tag_name and not template:
-        raise ValueError("One of template or tag_name is required.")
-    if isinstance(children, str):
-        children = [children]
-    childrenBlob = "\n".join(children)
-    attributesList = [f'{name} = "{value}"' for name, value in attributes]
-    attributesBlob = " ".join(attributesList)
-    tag: str = ""
-    if tag_name != "":
-        tag = f"<a {attributesBlob}>{childrenBlob}</a>"
-    elif template != "":
-        tag = render_to_string(
-            template,
-            {name: value for name, value in attributes} | {"slot": "\n".join(children)},
-        )
-    return mark_safe(tag)
-
-
-def A(
-    attributes: list[HTMLAttribute] = [],
-    children: list[HTMLTag] | HTMLTag = [],
-    url: str | Callable[..., Any] = "",
-):
-    """
-    Returns the HTML tag "a".
-    "url" can either be:
-        - URL (string)
-        - path name passed to reverse() (string)
-        - function
-    """
-    additional_attributes = []
-    if url:
-        if type(url) is str:
-            try:
-                url_result = reverse(url)
-            except NoReverseMatch:
-                url_result = url
-        elif callable(url):
-            url_result = url()
-        else:
-            raise TypeError("'url' is neither str nor function.")
-        additional_attributes = [("href", url_result)]
-    return Component(
-        tag_name="a", attributes=attributes + additional_attributes, children=children
-    )
-
-
-def Button(
-    attributes: list[HTMLAttribute] = [],
-    children: list[HTMLTag] | HTMLTag = [],
-):
-    return Component(
-        template="cotton/button.html", attributes=attributes, children=children
-    )
 
 
 def safe_division(numerator: int | float, denominator: int | float) -> int | float:
@@ -127,25 +42,29 @@ def safe_getattr(obj: object, attr_chain: str, default: Any | None = None) -> ob
     return obj
 
 
-def truncate(input_string: str, length: int = 30, ellipsis: str = "…") -> str:
+def truncate_(input_string: str, length: int = 30, ellipsis: str = "…") -> str:
     return (
-        (f"{input_string[:length-len(ellipsis)]}{ellipsis}")
+        (f"{input_string[: length - len(ellipsis)].rstrip()}{ellipsis}")
-        if len(input_string) > 30
+        if len(input_string) > length
         else input_string
     )
 
 
-def truncate_with_popover(input_string: str) -> str:
+def truncate(
-    if (truncated := truncate(input_string)) != input_string:
+    input_string: str, length: int = 30, ellipsis: str = "…", endpart: str = ""
-        print(f"Not the same after: {truncated=}")
+) -> str:
-        return Popover(wrapped_content=truncated, popover_content=input_string)
+    max_content_length = length - len(endpart)
-    else:
+    if max_content_length < 0:
-        print("Strings are the same!")
+        raise ValueError("Length cannot be shorter than the length of endpart.")
-        return input_string
 
+    if len(input_string) > max_content_length:
+        return f"{input_string[: max_content_length - len(ellipsis)].rstrip()}{ellipsis}{endpart}"
 
-def randomid(seed: str = "", length: int = 10) -> str:
+    return (
-    return seed + "".join(choices(ascii_lowercase, k=length))
+        f"{input_string}{endpart}"
+        if len(input_string) + len(endpart) <= length
+        else f"{input_string[: length - len(ellipsis) - len(endpart)].rstrip()}{ellipsis}{endpart}"
+    )
 
 
 T = TypeVar("T", str, int, date)
@@ -166,3 +85,83 @@ def generate_split_ranges(
         except IndexError:
             end = len(value_list)
         yield (value_list[start], value_list[end - 1])
+
+
+def format_float_or_int(number: int | float):
+    return int(number) if float(number).is_integer() else f"{number:03.2f}"
+
+
+OperatorType = Literal["|", "&"]
+
+
+@dataclass
+class FilterEntry:
+    condition: Q
+    operator: OperatorType = "&"
+
+
+def build_dynamic_filter(
+    filters: list[FilterEntry | Q], default_operator: OperatorType = "&"
+):
+    """
+    Constructs a Django Q filter from a list of filter conditions.
+
+    Args:
+        filters (list): A list where each item is either:
+            - A Q object (default AND logic applied)
+            - A tuple of (Q object, operator) where operator is "|" (OR) or "&" (AND)
+
+    Returns:
+        Q: A combined Q object that can be passed to Django's filter().
+    """
+    op_map: dict[OperatorType, Callable[[Q, Q], Q]] = {
+        "|": operator.or_,
+        "&": operator.and_,
+    }
+
+    # Convert all plain Q objects into (Q, "&") for default AND behavior
+    processed_filters = [
+        FilterEntry(f, default_operator) if isinstance(f, Q) else f for f in filters
+    ]
+
+    # Reduce with dynamic operators
+    return reduce(
+        lambda combined_filters, filter: op_map[filter.operator](
+            combined_filters, filter.condition
+        ),
+        processed_filters,
+        Q(),
+    )
+
+
+def redirect_to(default_view: str, *default_args):
+    """
+    A decorator that redirects the user back to the referring page or a default view if no 'next' parameter is provided.
+
+    :param default_view: The name of the default view to redirect to if 'next' is missing.
+    :param default_args: Any arguments required for the default view.
+    """
+
+    def decorator(view_func):
+        @wraps(view_func)
+        def wrapped_view(request: HttpRequest, *args, **kwargs):
+            next_url = request.GET.get("next")
+            if not next_url:
+                from django.urls import (
+                    reverse,  # Import inside function to avoid circular imports
+                )
+
+                next_url = reverse(default_view, args=default_args)
+
+            response = view_func(
+                request, *args, **kwargs
+            )  # Execute the original view logic
+            return redirect(next_url)
+
+        return wrapped_view
+
+    return decorator
+
+
+def add_next_param_to_url(url: str, nexturl: str) -> str:
+    return f"{url}?{urlencode({'next': nexturl})}"

contrib/scripts/get_exchange_rates_since_1990.py

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

contrib/scripts/merge_exchange_records.py

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

devcontainer.Dockerfile

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

entrypoint.sh

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

games/admin.py

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

games/api.py

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

games/apps.py

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

games/fixtures/exchangerates.yaml

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

games/forms.py

@@ -1,8 +1,17 @@
 from django import forms
+from django.db import transaction
 from django.urls import reverse
 
 from common.utils import safe_getattr
-from games.models import Device, Edition, Game, Platform, Purchase, Session
+from games.models import (
+    Device,
+    Game,
+    GameStatusChange,
+    Platform,
+    PlayEvent,
+    Purchase,
+    Session,
+)
 
 custom_date_widget = forms.DateInput(attrs={"type": "date"})
 custom_datetime_widget = forms.DateTimeInput(
@@ -11,17 +20,37 @@ 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):
-    # purchase = forms.ModelChoiceField(
+    game = SingleGameChoiceField(
-    #     queryset=Purchase.objects.filter(date_refunded=None).order_by("edition__name")
+        queryset=Game.objects.order_by("sort_name"),
-    # )
-    purchase = forms.ModelChoiceField(
-        queryset=Purchase.objects.order_by("edition__sort_name"),
         widget=forms.Select(attrs={"autofocus": "autofocus"}),
     )
 
+    duration_manual = forms.DurationField(
+        required=False,
+        widget=forms.TextInput(
+            attrs={"x-mask": "99:99:99", "placeholder": "HH:MM:SS", "x-data": ""}
+        ),
+        label="Manual duration",
+    )
     device = forms.ModelChoiceField(queryset=Device.objects.order_by("name"))
 
+    mark_as_played = forms.BooleanField(
+        required=False,
+        initial={"mark_as_played": True},
+        label="Set game status to Played if Unplayed",
+    )
+
     class Meta:
         widgets = {
             "timestamp_start": custom_datetime_widget,
@@ -29,21 +58,30 @@ class SessionForm(forms.ModelForm):
         }
         model = Session
         fields = [
-            "purchase",
+            "game",
             "timestamp_start",
             "timestamp_end",
             "duration_manual",
+            "emulated",
             "device",
             "note",
+            "mark_as_played",
         ]
 
-
+    def save(self, commit=True):
-class EditionChoiceField(forms.ModelChoiceField):
+        session = super().save(commit=False)
-    def label_from_instance(self, obj) -> str:
+        if self.cleaned_data.get("mark_as_played"):
-        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
+            game_instance = session.game
+            if game_instance.status == "u":
+                game_instance.status = "p"
+            if commit:
+                game_instance.save()
+        if commit:
+            session.save()
+        return session
 
 
-class IncludePlatformSelect(forms.Select):
+class IncludePlatformSelect(forms.SelectMultiple):
     def create_option(self, name, value, *args, **kwargs):
         option = super().create_option(name, value, *args, **kwargs)
         if platform_id := safe_getattr(value, "instance.platform.id"):
@@ -56,44 +94,50 @@ class PurchaseForm(forms.ModelForm):
         super().__init__(*args, **kwargs)
 
         # Automatically update related_purchase <select/>
-        # to only include purchases of the selected edition.
+        # to only include purchases of the selected game.
-        related_purchase_by_edition_url = reverse("related_purchase_by_edition")
+        related_purchase_by_game_url = reverse("related_purchase_by_game")
-        self.fields["edition"].widget.attrs.update(
+        self.fields["games"].widget.attrs.update(
             {
                 "hx-trigger": "load, click",
-                "hx-get": related_purchase_by_edition_url,
+                "hx-get": related_purchase_by_game_url,
                 "hx-target": "#id_related_purchase",
                 "hx-swap": "outerHTML",
             }
         )
 
-    edition = EditionChoiceField(
+    games = MultipleGameChoiceField(
-        queryset=Edition.objects.order_by("sort_name"),
+        queryset=Game.objects.order_by("sort_name"),
         widget=IncludePlatformSelect(attrs={"autoselect": "autoselect"}),
     )
     platform = forms.ModelChoiceField(queryset=Platform.objects.order_by("name"))
     related_purchase = forms.ModelChoiceField(
-        queryset=Purchase.objects.filter(type=Purchase.GAME).order_by(
+        queryset=Purchase.objects.filter(type=Purchase.GAME),
-            "edition__sort_name"
-        ),
         required=False,
     )
 
+    price_currency = forms.CharField(
+        widget=forms.TextInput(
+            attrs={
+                "x-mask": "aaa",
+                "placeholder": "CZK",
+                "x-data": "",
+                "class": "uppercase",
+            }
+        ),
+        label="Currency",
+    )
+
     class Meta:
         widgets = {
             "date_purchased": custom_date_widget,
             "date_refunded": custom_date_widget,
-            "date_finished": custom_date_widget,
-            "date_dropped": custom_date_widget,
         }
         model = Purchase
         fields = [
-            "edition",
+            "games",
             "platform",
             "date_purchased",
             "date_refunded",
-            "date_finished",
-            "date_dropped",
             "infinite",
             "price",
             "price_currency",
@@ -140,31 +184,34 @@ class GameModelChoiceField(forms.ModelChoiceField):
         return obj.sort_name
 
 
-class EditionForm(forms.ModelForm):
+class GameForm(forms.ModelForm):
-    game = GameModelChoiceField(
-        queryset=Game.objects.order_by("sort_name"),
-        widget=IncludeNameSelect(attrs={"autofocus": "autofocus"}),
-    )
     platform = forms.ModelChoiceField(
         queryset=Platform.objects.order_by("name"), required=False
     )
 
-    class Meta:
-        model = Edition
-        fields = ["game", "name", "sort_name", "platform", "year_released", "wikidata"]
-
-
-class GameForm(forms.ModelForm):
     class Meta:
         model = Game
-        fields = ["name", "sort_name", "year_released", "wikidata"]
+        fields = [
+            "name",
+            "sort_name",
+            "platform",
+            "original_year_released",
+            "year_released",
+            "status",
+            "mastered",
+            "wikidata",
+        ]
         widgets = {"name": autofocus_input_widget}
 
 
 class PlatformForm(forms.ModelForm):
     class Meta:
         model = Platform
-        fields = ["name", "group"]
+        fields = [
+            "name",
+            "icon",
+            "group",
+        ]
         widgets = {"name": autofocus_input_widget}
 
 
@@ -173,3 +220,48 @@ class DeviceForm(forms.ModelForm):
         model = Device
         fields = ["name", "type"]
         widgets = {"name": autofocus_input_widget}
+
+
+class PlayEventForm(forms.ModelForm):
+    game = GameModelChoiceField(
+        queryset=Game.objects.order_by("sort_name"),
+        widget=forms.Select(attrs={"autofocus": "autofocus"}),
+    )
+
+    mark_as_finished = forms.BooleanField(
+        required=False,
+        initial={"mark_as_finished": True},
+        label="Set game status to Finished",
+    )
+
+    class Meta:
+        model = PlayEvent
+        fields = ["game", "started", "ended", "note", "mark_as_finished"]
+        widgets = {
+            "started": custom_date_widget,
+            "ended": custom_date_widget,
+        }
+
+    def save(self, commit=True):
+        with transaction.atomic():
+            session = super().save(commit=False)
+            if self.cleaned_data.get("mark_as_finished"):
+                game_instance = session.game
+                game_instance.status = "f"
+                game_instance.save()
+            session.save()
+        return session
+
+
+class GameStatusChangeForm(forms.ModelForm):
+    class Meta:
+        model = GameStatusChange
+        fields = [
+            "game",
+            "old_status",
+            "new_status",
+            "timestamp",
+        ]
+        widgets = {
+            "timestamp": custom_datetime_widget,
+        }

games/graphql/queries/__init__.py

@@ -1,5 +1,4 @@
 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

games/graphql/queries/edition.py

@@ -1,11 +0,0 @@
-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/management/commands/schedule_convert_prices.py

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

games/migrations/0001_initial.py

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

games/migrations/0002_alter_session_duration_manual.py

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

games/migrations/0002_purchase_price_per_game.py

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

games/migrations/0003_alter_session_duration_manual_and_more.py

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

games/migrations/0003_purchase_updated_at.py

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

games/migrations/0004_alter_session_duration_manual.py

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

games/migrations/0004_purchase_num_purchases.py

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

games/migrations/0005_auto_20230109_1843.py

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

games/migrations/0005_game_mastered_game_status.py

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

games/migrations/0006_alter_game_sort_name_alter_game_wikidata_and_more.py

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

games/migrations/0006_auto_20230109_1904.py

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

games/migrations/0007_alter_purchase_game_alter_purchase_platform_and_more.py

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

games/migrations/0007_game_updated_at.py

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

games/migrations/0008_edition.py

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

games/migrations/0008_game_original_year_released_gamestatuschange_and_more.py

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

games/migrations/0009_create_editions.py

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

games/migrations/0009_remove_purchase_date_dropped_and_more.py

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

games/migrations/0010_alter_purchase_game.py

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

games/migrations/0010_remove_purchase_price_per_game.py

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

games/migrations/0011_purchase_price_per_game.py

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

games/migrations/0011_rename_game_purchase_edition.py

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

games/migrations/0012_alter_session_duration_calculated.py

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

games/migrations/0012_purchase_price_purchase_price_currency.py

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

games/migrations/0013_game_playtime.py

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

games/migrations/0013_purchase_ownership_type.py

@@ -1,31 +0,0 @@
-# Generated by Django 4.1.5 on 2023-02-18 19:54
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0012_purchase_price_purchase_price_currency"),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name="purchase",
-            name="ownership_type",
-            field=models.CharField(
-                choices=[
-                    ("ph", "Physical"),
-                    ("di", "Digital"),
-                    ("du", "Digital Upgrade"),
-                    ("re", "Rented"),
-                    ("bo", "Borrowed"),
-                    ("tr", "Trial"),
-                    ("de", "Demo"),
-                    ("pi", "Pirated"),
-                ],
-                default="di",
-                max_length=2,
-            ),
-        ),
-    ]

games/migrations/0014_device_session_device.py

@@ -1,52 +0,0 @@
-# Generated by Django 4.1.5 on 2023-02-18 19:59
-
-import django.db.models.deletion
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ("games", "0013_purchase_ownership_type"),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name="Device",
-            fields=[
-                (
-                    "id",
-                    models.BigAutoField(
-                        auto_created=True,
-                        primary_key=True,
-                        serialize=False,
-                        verbose_name="ID",
-                    ),
-                ),
-                ("name", models.CharField(max_length=255)),
-                (
-                    "type",
-                    models.CharField(
-                        choices=[
-                            ("pc", "PC"),
-                            ("co", "Console"),
-                            ("ha", "Handheld"),
-                            ("mo", "Mobile"),
-                            ("sbc", "Single-board computer"),
-                        ],
-                        default="pc",
-                        max_length=3,
-                    ),
-                ),
-            ],
-        ),
-        migrations.AddField(
-            model_name="session",
-            name="device",
-            field=models.ForeignKey(
-                null=True,
-                on_delete=django.db.models.deletion.CASCADE,
-                to="games.device",
-            ),
-        ),
-    ]

games/migrations/0014_session_duration_total.py

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

games/migrations/0015_edition_wikidata_edition_year_released.py

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

games/migrations/0016_alter_edition_platform_alter_edition_year_released_and_more.py

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

games/migrations/0016_alter_edition_platform_alter_edition_year_released_and_more_squashed_0022_rename_year_game_year_released.py

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

games/migrations/0017_alter_device_type_alter_purchase_platform.py

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

games/migrations/0018_auto_20231106_1825.py

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

games/migrations/0019_alter_edition_unique_together.py

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

games/migrations/0020_game_year.py

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

games/migrations/0021_auto_20231106_1909.py

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

games/migrations/0022_rename_year_game_year_released.py

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

games/migrations/0023_purchase_date_finished.py

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

games/migrations/0024_edition_sort_name.py

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

games/migrations/0025_game_sort_name.py

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

games/migrations/0026_purchase_type.py

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

games/migrations/0027_purchase_related_purchase.py

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

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

games/migrations/0029_alter_purchase_related_purchase.py

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

games/migrations/0030_alter_purchase_name.py

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

games/migrations/0031_device_created_at_edition_created_at_game_created_at_and_more.py

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

games/migrations/0032_alter_session_options_session_modified_at_and_more.py

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

games/migrations/0033_alter_edition_unique_together.py

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

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

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

@@ -1,19 +0,0 @@
-# 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/models.py

@@ -1,19 +1,63 @@
+import logging
 from datetime import timedelta
 
+import requests
 from django.core.exceptions import ValidationError
 from django.db import models
 from django.db.models import F, Sum
+from django.db.models.expressions import RawSQL
+from django.db.models.fields.generated import GeneratedField
+from django.db.models.functions import Coalesce
+from django.template.defaultfilters import floatformat, pluralize, slugify
 from django.utils import timezone
 
 from common.time import format_duration
 
+logger = logging.getLogger("games")
+
 
 class Game(models.Model):
+    class Meta:
+        unique_together = [["name", "platform", "year_released"]]
+
     name = models.CharField(max_length=255)
-    sort_name = models.CharField(max_length=255, null=True, blank=True, default=None)
+    sort_name = models.CharField(max_length=255, blank=True, default="")
     year_released = models.IntegerField(null=True, blank=True, default=None)
-    wikidata = models.CharField(max_length=50, null=True, blank=True, default=None)
+    original_year_released = models.IntegerField(null=True, blank=True, default=None)
+    wikidata = models.CharField(max_length=50, blank=True, default="")
+    platform = models.ForeignKey(
+        "Platform", on_delete=models.SET_DEFAULT, null=True, blank=True, default=None
+    )
+
+    playtime = models.DurationField(blank=True, editable=False, default=timedelta(0))
+
     created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    class Status(models.TextChoices):
+        UNPLAYED = (
+            "u",
+            "Unplayed",
+        )
+        PLAYED = (
+            "p",
+            "Played",
+        )
+        FINISHED = (
+            "f",
+            "Finished",
+        )
+        RETIRED = (
+            "r",
+            "Retired",
+        )
+        ABANDONED = (
+            "a",
+            "Abandoned",
+        )
+
+    status = models.CharField(max_length=1, choices=Status, default=Status.UNPLAYED)
+    mastered = models.BooleanField(default=False)
 
     session_average: float | int | timedelta | None
     session_count: int | None
@@ -21,32 +65,49 @@ class Game(models.Model):
     def __str__(self):
         return self.name
 
+    def finished(self):
+        return self.status == self.Status.FINISHED
+
+    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, null=True, blank=True, default=None)
+    group = models.CharField(max_length=255, blank=True, default="")
+    icon = models.SlugField(blank=True)
     created_at = models.DateTimeField(auto_now_add=True)
 
     def __str__(self):
         return self.name
 
-
+    def save(self, *args, **kwargs):
-class Edition(models.Model):
+        if not self.icon:
-    class Meta:
+            self.icon = slugify(self.name)
-        unique_together = [["name", "platform", "year_released"]]
+        super().save(*args, **kwargs)
-
-    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
 
 
 class PurchaseQueryset(models.QuerySet):
@@ -56,9 +117,6 @@ 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)
 
@@ -95,55 +153,103 @@ class Purchase(models.Model):
 
     objects = PurchaseQueryset().as_manager()
 
-    edition = models.ForeignKey(Edition, on_delete=models.CASCADE)
+    games = models.ManyToManyField(Game, related_name="purchases")
+
     platform = models.ForeignKey(
         Platform, on_delete=models.CASCADE, default=None, null=True, blank=True
     )
-    date_purchased = models.DateField()
+    date_purchased = models.DateField(verbose_name="Purchased")
-    date_refunded = models.DateField(blank=True, null=True)
+    date_refunded = models.DateField(blank=True, null=True, verbose_name="Refunded")
-    date_finished = models.DateField(blank=True, null=True)
-    date_dropped = models.DateField(blank=True, null=True)
     infinite = models.BooleanField(default=False)
-    price = models.IntegerField(default=0)
+    price = models.FloatField(default=0)
     price_currency = models.CharField(max_length=3, default="USD")
+    converted_price = models.FloatField(null=True)
+    converted_currency = models.CharField(max_length=3, blank=True, default="")
+    price_per_game = GeneratedField(
+        expression=Coalesce(F("converted_price"), F("price"), 0) / F("num_purchases"),
+        output_field=models.FloatField(),
+        db_persist=True,
+        editable=False,
+    )
+    num_purchases = models.IntegerField(default=0)
     ownership_type = models.CharField(
         max_length=2, choices=OWNERSHIP_TYPES, default=DIGITAL
     )
     type = models.CharField(max_length=255, choices=TYPES, default=GAME)
-    name = models.CharField(max_length=255, default="", null=True, blank=True)
+    name = models.CharField(max_length=255, blank=True, default="")
     related_purchase = models.ForeignKey(
         "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):
+        return (
+            f"{floatformat(self.converted_price, 0)} {self.converted_currency}"
+            if self.converted_price
+            else None
+        )
+
+    @property
+    def has_one_item(self):
+        return self.games.count() == 1
+
+    @property
+    def standardized_name(self):
+        return self.name or self.first_game.name
+
+    @property
+    def first_game(self):
+        return self.games.first()
 
     def __str__(self):
+        return self.standardized_name
+
+    @property
+    def full_name(self):
         additional_info = [
-            self.get_type_display() if self.type != Purchase.GAME else "",
+            str(item)
-            (
+            for item in [
-                f"{self.edition.platform} version on {self.platform}"
+                f"{self.num_purchases} game{pluralize(self.num_purchases)}",
-                if self.platform != self.edition.platform
+                self.date_purchased,
-                else self.platform
+                self.standardized_price,
-            ),
+            ]
-            self.edition.year_released,
+            if item
-            self.get_ownership_type_display(),
         ]
-        return f"{self.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 save(self, *args, **kwargs):
-        if self.type == Purchase.GAME:
+        if self.type != Purchase.GAME and not self.related_purchase:
-            self.name = ""
-        elif self.type != Purchase.GAME and not self.related_purchase:
             raise ValidationError(
                 f"{self.get_type_display()} must have a related purchase."
             )
+        if self.pk is not None:
+            # Retrieve the existing instance from the database
+            existing_purchase = Purchase.objects.get(pk=self.pk)
+            # If price has changed, reset converted fields
+            if existing_purchase.price_or_currency_differ_from(self):
+                from games.tasks import currency_to
+
+                exchange_rate = get_or_create_rate(
+                    self.price_currency, currency_to, self.date_purchased.year
+                )
+                if exchange_rate:
+                    self.converted_price = floatformat(self.price * exchange_rate, 0)
+                    self.converted_currency = currency_to
         super().save(*args, **kwargs)
 
 
@@ -175,11 +281,30 @@ class Session(models.Model):
     class Meta:
         get_latest_by = "timestamp_start"
 
-    purchase = models.ForeignKey(Purchase, on_delete=models.CASCADE)
+    game = models.ForeignKey(
-    timestamp_start = models.DateTimeField()
+        Game,
-    timestamp_end = models.DateTimeField(blank=True, null=True)
+        on_delete=models.CASCADE,
-    duration_manual = models.DurationField(blank=True, null=True, default=timedelta(0))
+        null=True,
-    duration_calculated = models.DurationField(blank=True, null=True)
+        default=None,
+        related_name="sessions",
+    )
+    timestamp_start = models.DateTimeField(verbose_name="Start")
+    timestamp_end = models.DateTimeField(blank=True, null=True, verbose_name="End")
+    duration_manual = models.DurationField(
+        blank=True, null=True, default=timedelta(0), verbose_name="Manual duration"
+    )
+    duration_calculated = GeneratedField(
+        expression=Coalesce(F("timestamp_end") - F("timestamp_start"), 0),
+        output_field=models.DurationField(),
+        db_persist=True,
+        editable=False,
+    )
+    duration_total = GeneratedField(
+        expression=F("duration_calculated") + F("duration_manual"),
+        output_field=models.DurationField(),
+        db_persist=True,
+        editable=False,
+    )
     device = models.ForeignKey(
         "Device",
         on_delete=models.SET_DEFAULT,
@@ -187,15 +312,17 @@ class Session(models.Model):
         blank=True,
         default=None,
     )
-    note = models.TextField(blank=True, null=True)
+    note = models.TextField(blank=True, default="")
+    emulated = models.BooleanField(default=False)
+
     created_at = models.DateTimeField(auto_now_add=True)
     modified_at = models.DateTimeField(auto_now=True)
 
     objects = SessionQuerySet.as_manager()
 
     def __str__(self):
-        mark = ", manual" if self.is_manual() else ""
+        mark = "*" if self.is_manual() else ""
-        return f"{str(self.purchase)} {str(self.timestamp_start.date())} ({self.duration_formatted()}{mark})"
+        return f"{str(self.game)} {str(self.timestamp_start.date())} ({self.duration_formatted()}{mark})"
 
     def finish_now(self):
         self.timestamp_end = timezone.now()
@@ -203,32 +330,18 @@ class Session(models.Model):
     def start_now():
         self.timestamp_start = timezone.now()
 
-    def duration_seconds(self) -> timedelta:
-        manual = timedelta(0)
-        calculated = timedelta(0)
-        if self.is_manual() 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(self) -> str:
-        result = format_duration(self.duration_seconds(), "%02.0H:%02.0m")
+        result = format_duration(self.duration_total, "%02.1H")
         return result
 
+    def duration_formatted_with_mark(self) -> str:
+        mark = "*" if self.is_manual() else ""
+        return f"{self.duration_formatted()}{mark}"
+
     def is_manual(self) -> bool:
         return not self.duration_manual == timedelta(0)
 
-    @property
-    def 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)
 
@@ -241,12 +354,12 @@ class Session(models.Model):
 
 
 class Device(models.Model):
-    PC = "pc"
+    PC = "PC"
-    CONSOLE = "co"
+    CONSOLE = "Console"
-    HANDHELD = "ha"
+    HANDHELD = "Handheld"
-    MOBILE = "mo"
+    MOBILE = "Mobile"
-    SBC = "sbc"
+    SBC = "Single-board computer"
-    UNKNOWN = "un"
+    UNKNOWN = "Unknown"
     DEVICE_TYPES = [
         (PC, "PC"),
         (CONSOLE, "Console"),
@@ -256,8 +369,115 @@ class Device(models.Model):
         (UNKNOWN, "Unknown"),
     ]
     name = models.CharField(max_length=255)
-    type = models.CharField(max_length=3, choices=DEVICE_TYPES, default=UNKNOWN)
+    type = models.CharField(max_length=255, choices=DEVICE_TYPES, default=UNKNOWN)
     created_at = models.DateTimeField(auto_now_add=True)
 
     def __str__(self):
-        return f"{self.name} ({self.get_type_display()})"
+        return f"{self.name} ({self.type})"
+
+
+class ExchangeRate(models.Model):
+    currency_from = models.CharField(max_length=255)
+    currency_to = models.CharField(max_length=255)
+    year = models.PositiveIntegerField()
+    rate = models.FloatField()
+
+    class Meta:
+        unique_together = ("currency_from", "currency_to", "year")
+
+    def __str__(self):
+        return f"{self.currency_from}/{self.currency_to} - {self.rate} ({self.year})"
+
+
+def get_or_create_rate(currency_from: str, currency_to: str, year: int) -> float | None:
+    exchange_rate = None
+    result = ExchangeRate.objects.filter(
+        currency_from=currency_from, currency_to=currency_to, year=year
+    )
+    if result:
+        exchange_rate = result[0].rate
+    else:
+        try:
+            # this API endpoint only accepts lowercase currency string
+            response = requests.get(
+                f"https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@{year}-01-01/v1/currencies/{currency_from.lower()}.json"
+            )
+            response.raise_for_status()
+            data = response.json()
+            currency_from_data = data.get(currency_from.lower())
+            rate = currency_from_data.get(currency_to.lower())
+
+            if rate:
+                logger.info(f"[convert_prices]: Got {rate}, saving...")
+                exchange_rate = ExchangeRate.objects.create(
+                    currency_from=currency_from,
+                    currency_to=currency_to,
+                    year=year,
+                    rate=floatformat(rate, 2),
+                )
+                exchange_rate = exchange_rate.rate
+            else:
+                logger.info("[convert_prices]: Could not get an exchange rate.")
+        except requests.RequestException as e:
+            logger.info(
+                f"[convert_prices]: Failed to fetch exchange rate for {currency_from}->{currency_to} in {year}: {e}"
+            )
+    return exchange_rate
+
+
+class PlayEvent(models.Model):
+    game = models.ForeignKey(Game, related_name="playevents", on_delete=models.CASCADE)
+    started = models.DateField(null=True, blank=True)
+    ended = models.DateField(null=True, blank=True)
+    days_to_finish = GeneratedField(
+        # special cases:
+        # missing ended, started, or both = 0
+        # same day = 1 day to finish
+        expression=RawSQL(
+            """
+            COALESCE(
+                CASE 
+                    WHEN date(ended) = date(started) THEN 1
+                    ELSE julianday(ended) - julianday(started)
+                END, 0
+            )
+            """,
+            [],
+        ),
+        output_field=models.IntegerField(),
+        db_persist=True,
+        editable=False,
+        blank=True,
+    )
+    note = models.CharField(max_length=255, blank=True, default="")
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+
+# class PlayMarker(models.Model):
+#     game = models.ForeignKey(Game, related_name="markers", on_delete=models.CASCADE)
+#     played_since = models.DurationField()
+#     played_total = models.DurationField()
+#     note = models.CharField(max_length=255)
+
+
+class GameStatusChange(models.Model):
+    """
+    Tracks changes to the status of a Game.
+    """
+
+    game = models.ForeignKey(
+        Game, on_delete=models.CASCADE, related_name="status_changes"
+    )
+    old_status = models.CharField(
+        max_length=1, choices=Game.Status.choices, blank=True, null=True
+    )
+    new_status = models.CharField(max_length=1, choices=Game.Status.choices)
+    timestamp = models.DateTimeField(null=True)
+
+    def __str__(self):
+        return f"{self.game.name}: {self.old_status or 'None'} -> {self.new_status} at {self.timestamp}"
+
+    class Meta:
+        ordering = ["-timestamp"]

games/signals.py

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

games/static/base.css

@@ -1,5 +1,113 @@
+*, ::before, ::after {
+  --tw-border-spacing-x: 0;
+  --tw-border-spacing-y: 0;
+  --tw-translate-x: 0;
+  --tw-translate-y: 0;
+  --tw-rotate: 0;
+  --tw-skew-x: 0;
+  --tw-skew-y: 0;
+  --tw-scale-x: 1;
+  --tw-scale-y: 1;
+  --tw-pan-x:  ;
+  --tw-pan-y:  ;
+  --tw-pinch-zoom:  ;
+  --tw-scroll-snap-strictness: proximity;
+  --tw-gradient-from-position:  ;
+  --tw-gradient-via-position:  ;
+  --tw-gradient-to-position:  ;
+  --tw-ordinal:  ;
+  --tw-slashed-zero:  ;
+  --tw-numeric-figure:  ;
+  --tw-numeric-spacing:  ;
+  --tw-numeric-fraction:  ;
+  --tw-ring-inset:  ;
+  --tw-ring-offset-width: 0px;
+  --tw-ring-offset-color: #fff;
+  --tw-ring-color: rgb(63 131 248 / 0.5);
+  --tw-ring-offset-shadow: 0 0 #0000;
+  --tw-ring-shadow: 0 0 #0000;
+  --tw-shadow: 0 0 #0000;
+  --tw-shadow-colored: 0 0 #0000;
+  --tw-blur:  ;
+  --tw-brightness:  ;
+  --tw-contrast:  ;
+  --tw-grayscale:  ;
+  --tw-hue-rotate:  ;
+  --tw-invert:  ;
+  --tw-saturate:  ;
+  --tw-sepia:  ;
+  --tw-drop-shadow:  ;
+  --tw-backdrop-blur:  ;
+  --tw-backdrop-brightness:  ;
+  --tw-backdrop-contrast:  ;
+  --tw-backdrop-grayscale:  ;
+  --tw-backdrop-hue-rotate:  ;
+  --tw-backdrop-invert:  ;
+  --tw-backdrop-opacity:  ;
+  --tw-backdrop-saturate:  ;
+  --tw-backdrop-sepia:  ;
+  --tw-contain-size:  ;
+  --tw-contain-layout:  ;
+  --tw-contain-paint:  ;
+  --tw-contain-style:  ;
+}
+
+::backdrop {
+  --tw-border-spacing-x: 0;
+  --tw-border-spacing-y: 0;
+  --tw-translate-x: 0;
+  --tw-translate-y: 0;
+  --tw-rotate: 0;
+  --tw-skew-x: 0;
+  --tw-skew-y: 0;
+  --tw-scale-x: 1;
+  --tw-scale-y: 1;
+  --tw-pan-x:  ;
+  --tw-pan-y:  ;
+  --tw-pinch-zoom:  ;
+  --tw-scroll-snap-strictness: proximity;
+  --tw-gradient-from-position:  ;
+  --tw-gradient-via-position:  ;
+  --tw-gradient-to-position:  ;
+  --tw-ordinal:  ;
+  --tw-slashed-zero:  ;
+  --tw-numeric-figure:  ;
+  --tw-numeric-spacing:  ;
+  --tw-numeric-fraction:  ;
+  --tw-ring-inset:  ;
+  --tw-ring-offset-width: 0px;
+  --tw-ring-offset-color: #fff;
+  --tw-ring-color: rgb(63 131 248 / 0.5);
+  --tw-ring-offset-shadow: 0 0 #0000;
+  --tw-ring-shadow: 0 0 #0000;
+  --tw-shadow: 0 0 #0000;
+  --tw-shadow-colored: 0 0 #0000;
+  --tw-blur:  ;
+  --tw-brightness:  ;
+  --tw-contrast:  ;
+  --tw-grayscale:  ;
+  --tw-hue-rotate:  ;
+  --tw-invert:  ;
+  --tw-saturate:  ;
+  --tw-sepia:  ;
+  --tw-drop-shadow:  ;
+  --tw-backdrop-blur:  ;
+  --tw-backdrop-brightness:  ;
+  --tw-backdrop-contrast:  ;
+  --tw-backdrop-grayscale:  ;
+  --tw-backdrop-hue-rotate:  ;
+  --tw-backdrop-invert:  ;
+  --tw-backdrop-opacity:  ;
+  --tw-backdrop-saturate:  ;
+  --tw-backdrop-sepia:  ;
+  --tw-contain-size:  ;
+  --tw-contain-layout:  ;
+  --tw-contain-paint:  ;
+  --tw-contain-style:  ;
+}
+
 /*
-! tailwindcss v3.4.10 | MIT License | https://tailwindcss.com
+! tailwindcss v3.4.14 | MIT License | https://tailwindcss.com
 */
 
 /*
@@ -442,7 +550,7 @@ video {
 
 /* Make elements with the HTML hidden attribute stay hidden by default */
 
-[hidden] {
+[hidden]:where(:not([hidden="until-found"])) {
   display: none;
 }
 
@@ -1104,114 +1212,6 @@ input:checked + .toggle-bg {
   border-color: #1C64F2;
 }
 
-*, ::before, ::after {
-  --tw-border-spacing-x: 0;
-  --tw-border-spacing-y: 0;
-  --tw-translate-x: 0;
-  --tw-translate-y: 0;
-  --tw-rotate: 0;
-  --tw-skew-x: 0;
-  --tw-skew-y: 0;
-  --tw-scale-x: 1;
-  --tw-scale-y: 1;
-  --tw-pan-x:  ;
-  --tw-pan-y:  ;
-  --tw-pinch-zoom:  ;
-  --tw-scroll-snap-strictness: proximity;
-  --tw-gradient-from-position:  ;
-  --tw-gradient-via-position:  ;
-  --tw-gradient-to-position:  ;
-  --tw-ordinal:  ;
-  --tw-slashed-zero:  ;
-  --tw-numeric-figure:  ;
-  --tw-numeric-spacing:  ;
-  --tw-numeric-fraction:  ;
-  --tw-ring-inset:  ;
-  --tw-ring-offset-width: 0px;
-  --tw-ring-offset-color: #fff;
-  --tw-ring-color: rgb(63 131 248 / 0.5);
-  --tw-ring-offset-shadow: 0 0 #0000;
-  --tw-ring-shadow: 0 0 #0000;
-  --tw-shadow: 0 0 #0000;
-  --tw-shadow-colored: 0 0 #0000;
-  --tw-blur:  ;
-  --tw-brightness:  ;
-  --tw-contrast:  ;
-  --tw-grayscale:  ;
-  --tw-hue-rotate:  ;
-  --tw-invert:  ;
-  --tw-saturate:  ;
-  --tw-sepia:  ;
-  --tw-drop-shadow:  ;
-  --tw-backdrop-blur:  ;
-  --tw-backdrop-brightness:  ;
-  --tw-backdrop-contrast:  ;
-  --tw-backdrop-grayscale:  ;
-  --tw-backdrop-hue-rotate:  ;
-  --tw-backdrop-invert:  ;
-  --tw-backdrop-opacity:  ;
-  --tw-backdrop-saturate:  ;
-  --tw-backdrop-sepia:  ;
-  --tw-contain-size:  ;
-  --tw-contain-layout:  ;
-  --tw-contain-paint:  ;
-  --tw-contain-style:  ;
-}
-
-::backdrop {
-  --tw-border-spacing-x: 0;
-  --tw-border-spacing-y: 0;
-  --tw-translate-x: 0;
-  --tw-translate-y: 0;
-  --tw-rotate: 0;
-  --tw-skew-x: 0;
-  --tw-skew-y: 0;
-  --tw-scale-x: 1;
-  --tw-scale-y: 1;
-  --tw-pan-x:  ;
-  --tw-pan-y:  ;
-  --tw-pinch-zoom:  ;
-  --tw-scroll-snap-strictness: proximity;
-  --tw-gradient-from-position:  ;
-  --tw-gradient-via-position:  ;
-  --tw-gradient-to-position:  ;
-  --tw-ordinal:  ;
-  --tw-slashed-zero:  ;
-  --tw-numeric-figure:  ;
-  --tw-numeric-spacing:  ;
-  --tw-numeric-fraction:  ;
-  --tw-ring-inset:  ;
-  --tw-ring-offset-width: 0px;
-  --tw-ring-offset-color: #fff;
-  --tw-ring-color: rgb(63 131 248 / 0.5);
-  --tw-ring-offset-shadow: 0 0 #0000;
-  --tw-ring-shadow: 0 0 #0000;
-  --tw-shadow: 0 0 #0000;
-  --tw-shadow-colored: 0 0 #0000;
-  --tw-blur:  ;
-  --tw-brightness:  ;
-  --tw-contrast:  ;
-  --tw-grayscale:  ;
-  --tw-hue-rotate:  ;
-  --tw-invert:  ;
-  --tw-saturate:  ;
-  --tw-sepia:  ;
-  --tw-drop-shadow:  ;
-  --tw-backdrop-blur:  ;
-  --tw-backdrop-brightness:  ;
-  --tw-backdrop-contrast:  ;
-  --tw-backdrop-grayscale:  ;
-  --tw-backdrop-hue-rotate:  ;
-  --tw-backdrop-invert:  ;
-  --tw-backdrop-opacity:  ;
-  --tw-backdrop-saturate:  ;
-  --tw-backdrop-sepia:  ;
-  --tw-contain-size:  ;
-  --tw-contain-layout:  ;
-  --tw-contain-paint:  ;
-  --tw-contain-style:  ;
-}
-
 .container {
   width: 100%;
 }
@@ -1258,6 +1258,10 @@ input:checked + .toggle-bg {
   border-width: 0;
 }
 
+.pointer-events-none {
+  pointer-events: none;
+}
+
 .visible {
   visibility: visible;
 }
@@ -1290,6 +1294,19 @@ input:checked + .toggle-bg {
   inset: 0px;
 }
 
+.inset-y-0 {
+  top: 0px;
+  bottom: 0px;
+}
+
+.-left-3 {
+  left: -0.75rem;
+}
+
+.-left-\[1px\] {
+  left: -1px;
+}
+
 .bottom-0 {
   bottom: 0px;
 }
@@ -1318,14 +1335,26 @@ input:checked + .toggle-bg {
   right: 0.75rem;
 }
 
+.start-0 {
+  inset-inline-start: 0px;
+}
+
 .top-0 {
   top: 0px;
 }
 
+.top-2 {
+  top: 0.5rem;
+}
+
 .top-3 {
   top: 0.75rem;
 }
 
+.top-\[100\%\] {
+  top: 100%;
+}
+
 .z-10 {
   z-index: 10;
 }
@@ -1346,6 +1375,10 @@ input:checked + .toggle-bg {
   z-index: 50;
 }
 
+.m-4 {
+  margin: 1rem;
+}
+
 .mx-2 {
   margin-left: 0.5rem;
   margin-right: 0.5rem;
@@ -1398,6 +1431,10 @@ input:checked + .toggle-bg {
   margin-inline-end: 0.5rem;
 }
 
+.ml-3 {
+  margin-left: 0.75rem;
+}
+
 .mr-4 {
   margin-right: 1rem;
 }
@@ -1414,6 +1451,10 @@ input:checked + .toggle-bg {
   margin-inline-start: 0.625rem;
 }
 
+.mt-1 {
+  margin-top: 0.25rem;
+}
+
 .mt-2 {
   margin-top: 0.5rem;
 }
@@ -1467,6 +1508,10 @@ input:checked + .toggle-bg {
   height: 3rem;
 }
 
+.h-2 {
+  height: 0.5rem;
+}
+
 .h-2\.5 {
   height: 0.625rem;
 }
@@ -1503,6 +1548,10 @@ input:checked + .toggle-bg {
   width: 2.5rem;
 }
 
+.w-2 {
+  width: 0.5rem;
+}
+
 .w-2\.5 {
   width: 0.625rem;
 }
@@ -1511,6 +1560,10 @@ input:checked + .toggle-bg {
   width: 6rem;
 }
 
+.w-3 {
+  width: 0.75rem;
+}
+
 .w-4 {
   width: 1rem;
 }
@@ -1531,12 +1584,20 @@ input:checked + .toggle-bg {
   width: 16rem;
 }
 
+.w-80 {
+  width: 20rem;
+}
+
+.w-auto {
+  width: auto;
+}
+
 .w-full {
   width: 100%;
 }
 
-.max-w-80 {
+.max-w-\[30rem\] {
-  max-width: 20rem;
+  max-width: 30rem;
 }
 
 .max-w-screen-lg {
@@ -1551,6 +1612,10 @@ input:checked + .toggle-bg {
   max-width: 24rem;
 }
 
+.max-w-xl {
+  max-width: 36rem;
+}
+
 .max-w-xs {
   max-width: 20rem;
 }
@@ -1627,6 +1692,14 @@ input:checked + .toggle-bg {
   resize: both;
 }
 
+.list-inside {
+  list-style-position: inside;
+}
+
+.list-disc {
+  list-style-type: disc;
+}
+
 .grid-cols-4 {
   grid-template-columns: repeat(4, minmax(0, 1fr));
 }
@@ -1671,6 +1744,10 @@ input:checked + .toggle-bg {
   justify-content: space-between;
 }
 
+.gap-1 {
+  gap: 0.25rem;
+}
+
 .gap-2 {
   gap: 0.5rem;
 }
@@ -1683,6 +1760,10 @@ input:checked + .toggle-bg {
   gap: 1.25rem;
 }
 
+.gap-y-4 {
+  row-gap: 1rem;
+}
+
 .-space-x-px > :not([hidden]) ~ :not([hidden]) {
   --tw-space-x-reverse: 0;
   margin-right: calc(-1px * var(--tw-space-x-reverse));
@@ -1734,8 +1815,8 @@ input:checked + .toggle-bg {
   white-space: nowrap;
 }
 
-.text-wrap {
+.text-balance {
-  text-wrap: wrap;
+  text-wrap: balance;
 }
 
 .rounded {
@@ -1754,6 +1835,15 @@ input:checked + .toggle-bg {
   border-radius: 0.125rem;
 }
 
+.rounded-xl {
+  border-radius: 0.75rem;
+}
+
+.rounded-b-md {
+  border-bottom-right-radius: 0.375rem;
+  border-bottom-left-radius: 0.375rem;
+}
+
 .rounded-e-lg {
   border-start-end-radius: 0.5rem;
   border-end-end-radius: 0.5rem;
@@ -1774,6 +1864,14 @@ input:checked + .toggle-bg {
   border-end-start-radius: 0.5rem;
 }
 
+.rounded-tl-none {
+  border-top-left-radius: 0px;
+}
+
+.rounded-tr-md {
+  border-top-right-radius: 0.375rem;
+}
+
 .border {
   border-width: 1px;
 }
@@ -1782,6 +1880,18 @@ input:checked + .toggle-bg {
   border-width: 0px;
 }
 
+.border-b {
+  border-bottom-width: 1px;
+}
+
+.border-e {
+  border-inline-end-width: 1px;
+}
+
+.border-t {
+  border-top-width: 1px;
+}
+
 .border-blue-600 {
   --tw-border-opacity: 1;
   border-color: rgb(28 100 242 / var(--tw-border-opacity));
@@ -1847,20 +1957,59 @@ input:checked + .toggle-bg {
   background-color: rgb(249 250 251 / var(--tw-bg-opacity));
 }
 
+.bg-gray-500 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(107 114 128 / var(--tw-bg-opacity));
+}
+
 .bg-gray-800 {
   --tw-bg-opacity: 1;
   background-color: rgb(31 41 55 / var(--tw-bg-opacity));
 }
 
+.bg-gray-800\/20 {
+  background-color: rgb(31 41 55 / 0.2);
+}
+
 .bg-gray-900\/50 {
   background-color: rgb(17 24 39 / 0.5);
 }
 
+.bg-green-500 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(14 159 110 / var(--tw-bg-opacity));
+}
+
 .bg-green-600 {
   --tw-bg-opacity: 1;
   background-color: rgb(5 122 85 / var(--tw-bg-opacity));
 }
 
+.bg-green-700 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(4 108 78 / var(--tw-bg-opacity));
+}
+
+.bg-orange-400 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(255 138 76 / var(--tw-bg-opacity));
+}
+
+.bg-purple-500 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(144 97 249 / var(--tw-bg-opacity));
+}
+
+.bg-red-500 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(240 82 82 / var(--tw-bg-opacity));
+}
+
+.bg-red-700 {
+  --tw-bg-opacity: 1;
+  background-color: rgb(200 30 30 / var(--tw-bg-opacity));
+}
+
 .bg-white {
   --tw-bg-opacity: 1;
   background-color: rgb(255 255 255 / var(--tw-bg-opacity));
@@ -1941,11 +2090,28 @@ input:checked + .toggle-bg {
   padding-bottom: 0.75rem;
 }
 
+.py-3\.5 {
+  padding-top: 0.875rem;
+  padding-bottom: 0.875rem;
+}
+
 .py-4 {
   padding-top: 1rem;
   padding-bottom: 1rem;
 }
 
+.pb-4 {
+  padding-bottom: 1rem;
+}
+
+.ps-10 {
+  padding-inline-start: 2.5rem;
+}
+
+.ps-3 {
+  padding-inline-start: 0.75rem;
+}
+
 .pt-2 {
   padding-top: 0.5rem;
 }
@@ -1970,6 +2136,10 @@ input:checked + .toggle-bg {
   vertical-align: top;
 }
 
+.align-middle {
+  vertical-align: middle;
+}
+
 .font-mono {
   font-family: IBM Plex Mono, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
 }
@@ -2067,6 +2237,11 @@ input:checked + .toggle-bg {
   letter-spacing: -0.025em;
 }
 
+.text-black {
+  --tw-text-opacity: 1;
+  color: rgb(0 0 0 / var(--tw-text-opacity));
+}
+
 .text-blue-600 {
   --tw-text-opacity: 1;
   color: rgb(28 100 242 / var(--tw-text-opacity));
@@ -2107,16 +2282,16 @@ input:checked + .toggle-bg {
   color: rgb(17 24 39 / var(--tw-text-opacity));
 }
 
-.text-red-600 {
-  --tw-text-opacity: 1;
-  color: rgb(224 36 36 / var(--tw-text-opacity));
-}
-
 .text-slate-300 {
   --tw-text-opacity: 1;
   color: rgb(203 213 225 / var(--tw-text-opacity));
 }
 
+.text-slate-400 {
+  --tw-text-opacity: 1;
+  color: rgb(148 163 184 / var(--tw-text-opacity));
+}
+
 .text-slate-500 {
   --tw-text-opacity: 1;
   color: rgb(100 116 139 / var(--tw-text-opacity));
@@ -2140,6 +2315,10 @@ input:checked + .toggle-bg {
   text-decoration-color: #64748b;
 }
 
+.decoration-dotted {
+  text-decoration-style: dotted;
+}
+
 .opacity-0 {
   opacity: 0;
 }
@@ -2185,6 +2364,12 @@ input:checked + .toggle-bg {
   filter: var(--tw-blur) var(--tw-brightness) var(--tw-contrast) var(--tw-grayscale) var(--tw-hue-rotate) var(--tw-invert) var(--tw-saturate) var(--tw-sepia) var(--tw-drop-shadow);
 }
 
+.backdrop-blur-lg {
+  --tw-backdrop-blur: blur(16px);
+  -webkit-backdrop-filter: var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);
+  backdrop-filter: var(--tw-backdrop-blur) var(--tw-backdrop-brightness) var(--tw-backdrop-contrast) var(--tw-backdrop-grayscale) var(--tw-backdrop-hue-rotate) var(--tw-backdrop-invert) var(--tw-backdrop-opacity) var(--tw-backdrop-saturate) var(--tw-backdrop-sepia);
+}
+
 .transition {
   transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, -webkit-backdrop-filter;
   transition-property: color, background-color, border-color, text-decoration-color, fill, stroke, opacity, box-shadow, transform, filter, backdrop-filter;
@@ -2285,10 +2470,9 @@ input:checked + .toggle-bg {
   transition: all 0.2s ease-out;
 } */
 
-form label:is(.dark *) {
+/* form label {
-  --tw-text-opacity: 1;
+  @apply dark:text-slate-400;
-  color: rgb(148 163 184 / var(--tw-text-opacity));
+} */
-}
 
 .responsive-table {
   margin-left: auto;
@@ -2327,25 +2511,25 @@ form label:is(.dark *) {
   border-left-color: rgb(100 116 139 / var(--tw-border-opacity));
 }
 
-form input:is(.dark *),
+/* form input,
-select:is(.dark *),
+select,
-textarea:is(.dark *) {
+textarea {
-  border-width: 1px;
+  @apply dark:border dark:border-slate-900 dark:bg-slate-500 dark:text-slate-100;
-  --tw-border-opacity: 1;
+} */
-  border-color: rgb(15 23 42 / var(--tw-border-opacity));
+
-  --tw-bg-opacity: 1;
+form input:disabled,
-  background-color: rgb(100 116 139 / var(--tw-bg-opacity));
+select:disabled,
-  --tw-text-opacity: 1;
+textarea:disabled {
-  color: rgb(241 245 249 / var(--tw-text-opacity));
+  cursor: not-allowed;
 }
 
 form input:disabled:is(.dark *),
 select:disabled:is(.dark *),
 textarea:disabled:is(.dark *) {
   --tw-bg-opacity: 1;
-  background-color: rgb(51 65 85 / var(--tw-bg-opacity));
+  background-color: rgb(30 41 59 / var(--tw-bg-opacity));
   --tw-text-opacity: 1;
-  color: rgb(148 163 184 / var(--tw-text-opacity));
+  color: rgb(100 116 139 / var(--tw-text-opacity));
 }
 
 .errorlist {
@@ -2361,21 +2545,21 @@ textarea:disabled:is(.dark *) {
   color: rgb(226 232 240 / var(--tw-text-opacity));
 }
 
-@media screen and (min-width: 768px) {
+/* @media screen and (min-width: 768px) {
   form input,
   select,
   textarea {
     width: 300px;
   }
-}
+} */
 
-@media screen and (max-width: 768px) {
+/* @media screen and (max-width: 768px) {
   form input,
   select,
   textarea {
     width: 150px;
   }
-}
+} */
 
 #button-container button {
   margin-left: 0.25rem;
@@ -2484,6 +2668,47 @@ textarea:disabled:is(.dark *) {
   }  
 } */
 
+label:is(.dark *) {
+  --tw-text-opacity: 1;
+  color: rgb(100 116 139 / var(--tw-text-opacity));
+}
+
+[type="text"]:is(.dark *), [type="password"]:is(.dark *), [type="datetime-local"]:is(.dark *), [type="datetime"]:is(.dark *), [type="date"]:is(.dark *), [type="number"]:is(.dark *), select:is(.dark *), textarea:is(.dark *) {
+  --tw-bg-opacity: 1;
+  background-color: rgb(71 85 105 / var(--tw-bg-opacity));
+  --tw-text-opacity: 1;
+  color: rgb(203 213 225 / var(--tw-text-opacity));
+}
+
+[type="submit"] {
+  padding-left: 1rem;
+  padding-right: 1rem;
+  padding-top: 0.5rem;
+  padding-bottom: 0.5rem;
+  font-weight: 700;
+}
+
+[type="submit"]:is(.dark *) {
+  --tw-bg-opacity: 1;
+  background-color: rgb(28 100 242 / var(--tw-bg-opacity));
+  --tw-text-opacity: 1;
+  color: rgb(255 255 255 / var(--tw-text-opacity));
+}
+
+form div label:is(.dark *) {
+  --tw-text-opacity: 1;
+  color: rgb(255 255 255 / var(--tw-text-opacity));
+}
+
+form div {
+  display: flex;
+  flex-direction: column;
+}
+
+div [type="submit"] {
+  margin-top: 0.75rem;
+}
+
 .odd\:bg-white:nth-child(odd) {
   --tw-bg-opacity: 1;
   background-color: rgb(255 255 255 / var(--tw-bg-opacity));
@@ -2529,6 +2754,11 @@ textarea:disabled:is(.dark *) {
   background-color: rgb(4 108 78 / var(--tw-bg-opacity));
 }
 
+.hover\:bg-green-800:hover {
+  --tw-bg-opacity: 1;
+  background-color: rgb(3 84 63 / var(--tw-bg-opacity));
+}
+
 .hover\:bg-red-100:hover {
   --tw-bg-opacity: 1;
   background-color: rgb(253 232 232 / var(--tw-bg-opacity));
@@ -2539,6 +2769,11 @@ textarea:disabled:is(.dark *) {
   background-color: rgb(240 82 82 / var(--tw-bg-opacity));
 }
 
+.hover\:bg-red-800:hover {
+  --tw-bg-opacity: 1;
+  background-color: rgb(155 28 28 / var(--tw-bg-opacity));
+}
+
 .hover\:bg-white:hover {
   --tw-bg-opacity: 1;
   background-color: rgb(255 255 255 / var(--tw-bg-opacity));
@@ -2578,6 +2813,11 @@ textarea:disabled:is(.dark *) {
   z-index: 10;
 }
 
+.focus\:border-blue-500:focus {
+  --tw-border-opacity: 1;
+  border-color: rgb(63 131 248 / var(--tw-border-opacity));
+}
+
 .focus\:text-blue-700:focus {
   --tw-text-opacity: 1;
   color: rgb(26 86 219 / var(--tw-text-opacity));
@@ -2605,16 +2845,31 @@ textarea:disabled:is(.dark *) {
   --tw-ring-color: rgb(164 202 254 / var(--tw-ring-opacity));
 }
 
+.focus\:ring-blue-500:focus {
+  --tw-ring-opacity: 1;
+  --tw-ring-color: rgb(63 131 248 / var(--tw-ring-opacity));
+}
+
 .focus\:ring-blue-700:focus {
   --tw-ring-opacity: 1;
   --tw-ring-color: rgb(26 86 219 / var(--tw-ring-opacity));
 }
 
+.focus\:ring-gray-100:focus {
+  --tw-ring-opacity: 1;
+  --tw-ring-color: rgb(243 244 246 / var(--tw-ring-opacity));
+}
+
 .focus\:ring-gray-200:focus {
   --tw-ring-opacity: 1;
   --tw-ring-color: rgb(229 231 235 / var(--tw-ring-opacity));
 }
 
+.focus\:ring-green-300:focus {
+  --tw-ring-opacity: 1;
+  --tw-ring-color: rgb(132 225 188 / var(--tw-ring-opacity));
+}
+
 .focus\:ring-green-500:focus {
   --tw-ring-opacity: 1;
   --tw-ring-color: rgb(14 159 110 / var(--tw-ring-opacity));
@@ -2625,6 +2880,11 @@ textarea:disabled:is(.dark *) {
   --tw-ring-color: rgb(4 108 78 / var(--tw-ring-opacity));
 }
 
+.focus\:ring-red-300:focus {
+  --tw-ring-opacity: 1;
+  --tw-ring-color: rgb(248 180 180 / var(--tw-ring-opacity));
+}
+
 .focus\:ring-offset-2:focus {
   --tw-ring-offset-width: 2px;
 }
@@ -2771,11 +3031,21 @@ textarea:disabled:is(.dark *) {
   background-color: rgb(17 24 39 / 0.8);
 }
 
+.dark\:bg-green-600:is(.dark *) {
+  --tw-bg-opacity: 1;
+  background-color: rgb(5 122 85 / var(--tw-bg-opacity));
+}
+
 .dark\:bg-purple-800:is(.dark *) {
   --tw-bg-opacity: 1;
   background-color: rgb(85 33 181 / var(--tw-bg-opacity));
 }
 
+.dark\:bg-red-600:is(.dark *) {
+  --tw-bg-opacity: 1;
+  background-color: rgb(224 36 36 / var(--tw-bg-opacity));
+}
+
 .dark\:text-blue-500:is(.dark *) {
   --tw-text-opacity: 1;
   color: rgb(63 131 248 / var(--tw-text-opacity));
@@ -2821,6 +3091,16 @@ textarea:disabled:is(.dark *) {
   color: rgb(255 255 255 / var(--tw-text-opacity));
 }
 
+.dark\:placeholder-gray-400:is(.dark *)::-moz-placeholder {
+  --tw-placeholder-opacity: 1;
+  color: rgb(156 163 175 / var(--tw-placeholder-opacity));
+}
+
+.dark\:placeholder-gray-400:is(.dark *)::placeholder {
+  --tw-placeholder-opacity: 1;
+  color: rgb(156 163 175 / var(--tw-placeholder-opacity));
+}
+
 .odd\:dark\:bg-gray-900:is(.dark *):nth-child(odd) {
   --tw-bg-opacity: 1;
   background-color: rgb(17 24 39 / var(--tw-bg-opacity));
@@ -2866,6 +3146,11 @@ textarea:disabled:is(.dark *) {
   background-color: rgb(5 122 85 / var(--tw-bg-opacity));
 }
 
+.dark\:hover\:bg-green-700:hover:is(.dark *) {
+  --tw-bg-opacity: 1;
+  background-color: rgb(4 108 78 / var(--tw-bg-opacity));
+}
+
 .dark\:hover\:bg-red-700:hover:is(.dark *) {
   --tw-bg-opacity: 1;
   background-color: rgb(200 30 30 / var(--tw-bg-opacity));
@@ -2886,6 +3171,11 @@ textarea:disabled:is(.dark *) {
   color: rgb(255 255 255 / var(--tw-text-opacity));
 }
 
+.dark\:focus\:border-blue-500:focus:is(.dark *) {
+  --tw-border-opacity: 1;
+  border-color: rgb(63 131 248 / var(--tw-border-opacity));
+}
+
 .dark\:focus\:text-white:focus:is(.dark *) {
   --tw-text-opacity: 1;
   color: rgb(255 255 255 / var(--tw-text-opacity));
@@ -2906,11 +3196,26 @@ textarea:disabled:is(.dark *) {
   --tw-ring-color: rgb(75 85 99 / var(--tw-ring-opacity));
 }
 
+.dark\:focus\:ring-gray-700:focus:is(.dark *) {
+  --tw-ring-opacity: 1;
+  --tw-ring-color: rgb(55 65 81 / var(--tw-ring-opacity));
+}
+
 .dark\:focus\:ring-green-500:focus:is(.dark *) {
   --tw-ring-opacity: 1;
   --tw-ring-color: rgb(14 159 110 / var(--tw-ring-opacity));
 }
 
+.dark\:focus\:ring-green-800:focus:is(.dark *) {
+  --tw-ring-opacity: 1;
+  --tw-ring-color: rgb(3 84 63 / var(--tw-ring-opacity));
+}
+
+.dark\:focus\:ring-red-900:focus:is(.dark *) {
+  --tw-ring-opacity: 1;
+  --tw-ring-color: rgb(119 29 29 / var(--tw-ring-opacity));
+}
+
 @media (min-width: 640px) {
   .sm\:table-cell {
     display: table-cell;
@@ -2985,6 +3290,10 @@ textarea:disabled:is(.dark *) {
     flex-direction: row;
   }
 
+  .md\:justify-between {
+    justify-content: space-between;
+  }
+
   .md\:space-x-8 > :not([hidden]) ~ :not([hidden]) {
     --tw-space-x-reverse: 0;
     margin-right: calc(2rem * var(--tw-space-x-reverse));
@@ -3120,3 +3429,21 @@ textarea:disabled:is(.dark *) {
 .\[\&_a\]\:underline-offset-4 a {
   text-underline-offset: 4px;
 }
+
+.\[\&_h1\]\:mb-2 h1 {
+  margin-bottom: 0.5rem;
+}
+
+.\[\&_td\:last-child\]\:text-right td:last-child {
+  text-align: right;
+}
+
+@media not all and (min-width: 640px) {
+  .\[\&_td\:not\(\:first-child\)\:not\(\:last-child\)\]\:max-sm\:hidden td:not(:first-child):not(:last-child) {
+    display: none;
+  }
+
+  .\[\&_th\:not\(\:first-child\)\:not\(\:last-child\)\]\:max-sm\:hidden th:not(:first-child):not(:last-child) {
+    display: none;
+  }
+}

games/static/js/add_purchase.js

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

games/static/main.js

@@ -36,7 +36,7 @@ function addToggleButton(targetNode) {
   targetNode.parentElement.appendChild(manualToggleButton);
 }
 
-const toggleableFields = ["#id_game", "#id_edition", "#id_platform"];
+const toggleableFields = ["#id_games", "#id_platform"];
 
 toggleableFields.map((selector) => {
   addToggleButton(document.querySelector(selector));

games/tasks.py

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

games/templates/add.html

@@ -1,24 +1,2 @@
-{% extends "base.html" %}
+<c-layouts.add>
-{% load static %}
+</c-layouts.add>
-{% block title %}
-    {{ title }}
-{% endblock title %}
-{% block content %}
-    <form method="post" enctype="multipart/form-data">
-        <table class="mx-auto">
-            {% csrf_token %}
-            {{ form.as_table }}
-            <tr>
-                <td></td>
-                <td>
-                    <input type="submit" value="Submit" />
-                </td>
-            </tr>
-        </table>
-    </form>
-{% endblock content %}
-{% block scripts %}
-    {% if script_name %}
-        <script type="module" src="{% static 'js/'|add:script_name %}"></script>
-    {% endif %}
-{% endblock scripts %}

games/templates/add_edition.html

@@ -1,32 +0,0 @@
-{% extends "base.html" %}
-{% load static %}
-{% block title %}
-    {{ title }}
-{% endblock title %}
-{% block content %}
-    <form method="post" enctype="multipart/form-data">
-        <table class="mx-auto">
-            {% csrf_token %}
-            {{ form.as_table }}
-            <tr>
-                <td></td>
-                <td>
-                    <input type="submit" name="submit" value="Submit" />
-                </td>
-            </tr>
-            <tr>
-                <td></td>
-                <td>
-                    <input type="submit"
-                           name="submit_and_redirect"
-                           value="Submit & Create Purchase" />
-                </td>
-            </tr>
-        </table>
-    </form>
-{% endblock content %}
-{% block scripts %}
-    {% if script_name %}
-        <script type="module" src="{% static 'js/'|add:script_name %}"></script>
-    {% endif %}
-{% endblock scripts %}

games/templates/add_game.html

@@ -1,32 +1,7 @@
-{% extends "base.html" %}
+<c-layouts.add>
-{% load static %}
+<c-slot name="additional_row">
-{% block title %}
+    <input type="submit"
-    {{ title }}
+                        name="submit_and_redirect"
-{% endblock title %}
+                        value="Submit & Create Purchase" />
-{% block content %}
+</c-slot>
-    <form method="post" enctype="multipart/form-data">
+</c-layouts.add>
-        <table class="mx-auto">
-            {% csrf_token %}
-            {{ form.as_table }}
-            <tr>
-                <td></td>
-                <td>
-                    <input type="submit" name="submit" value="Submit" />
-                </td>
-            </tr>
-            <tr>
-                <td></td>
-                <td>
-                    <input type="submit"
-                           name="submit_and_redirect"
-                           value="Submit & Create Edition" />
-                </td>
-            </tr>
-        </table>
-    </form>
-{% endblock content %}
-{% block scripts %}
-    {% if script_name %}
-        <script type="module" src="{% static 'js/'|add:script_name %}"></script>
-    {% endif %}
-{% endblock scripts %}

games/templates/add_purchase.html

@@ -1,42 +1,12 @@
-{% extends "base.html" %}
+<c-layouts.add>
-{% load static %}
+<c-slot name="additional_row">
-{% block title %}
+<tr>
-    {{ title }}
+    <td></td>
-{% endblock title %}
+    <td>
-{% block content %}
+        <input type="submit"
-    <form method="post" enctype="multipart/form-data">
+               name="submit_and_redirect"
-        <table class="mx-auto">
+               value="Submit & Create Session" />
-            {% csrf_token %}
+    </td>
-            {{ form.as_table }}
+</tr>
-            <tr>
+</c-slot>
-                <td></td>
+</c-layouts.add>
-                <td>
-                    <input type="submit" name="submit" value="Submit" />
-                </td>
-            </tr>
-            <tr>
-                <td></td>
-                <td>
-                    <input type="submit"
-                           name="submit_and_redirect"
-                           value="Submit & Create Session" />
-                </td>
-            </tr>
-            {% if purchase_id %}
-                <tr>
-                    <td></td>
-                    <td>
-                        <a href="{% url 'delete_purchase' purchase_id %}"
-                           class="text-red-600"
-                           onclick="return confirm('Are you sure you want to delete this purchase?');">Delete</a>
-                    </td>
-                </tr>
-            {% endif %}
-        </table>
-    </form>
-{% endblock content %}
-{% block scripts %}
-    {% if script_name %}
-        <script type="module" src="{% static 'js/'|add:script_name %}"></script>
-    {% endif %}
-{% endblock scripts %}

games/templates/add_session.html

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

games/templates/base.html

@@ -1,90 +0,0 @@
-{% load django_htmx %}
-<!DOCTYPE html>
-<html lang="en">
-    {% load static %}
-    <head>
-        <meta charset="utf-8" />
-        <meta name="description" content="Self-hosted time-tracker." />
-        <meta name="keywords" content="time, tracking, video games, self-hosted" />
-        <meta name="viewport" content="width=device-width, initial-scale=1" />
-        <title>Timetracker -
-            {% block title %}
-                Untitled
-            {% endblock title %}
-        </title>
-        <script src="{% static 'js/htmx.min.js' %}"></script>
-        {% django_htmx_script %}
-        <link rel="stylesheet" href="{% static 'base.css' %}" />
-        <script src="https://cdn.jsdelivr.net/npm/flowbite@2.4.1/dist/flowbite.min.js"></script>
-        <script>
-        // On page load or when changing themes, best to add inline in `head` to avoid FOUC
-        if (localStorage.getItem('color-theme') === 'dark' || (!('color-theme' in localStorage) && window.matchMedia('(prefers-color-scheme: dark)').matches)) {
-            document.documentElement.classList.add('dark');
-        } else {
-            document.documentElement.classList.remove('dark')
-        }
-        </script>
-    </head>
-    <body hx-indicator="#indicator">
-        <img id="indicator"
-             src="{% static 'icons/loading.png' %}"
-             class="absolute right-3 top-3 animate-spin htmx-indicator"
-             height="24"
-             width="24"
-             alt="loading indicator" />
-        <div class="flex flex-col min-h-screen">
-            {% include "navbar.html" %}
-            <div class="flex flex-1 flex-col dark:bg-gray-800 pt-8">
-                {% block content %}
-                    No content here.
-                {% endblock content %}
-            </div>
-            {% load version %}
-            <span class="fixed left-2 bottom-2 text-xs text-slate-300 dark:text-slate-600">{% version %} ({% version_date %})</span>
-        </div>
-        {% block scripts %}
-        {% endblock scripts %}
-        <script>
-        var themeToggleDarkIcon = document.getElementById('theme-toggle-dark-icon');
-        var themeToggleLightIcon = document.getElementById('theme-toggle-light-icon');
-
-        // Change the icons inside the button based on previous settings
-        if (localStorage.getItem('color-theme') === 'dark' || (!('color-theme' in localStorage) && window.matchMedia('(prefers-color-scheme: dark)').matches)) {
-            themeToggleLightIcon.classList.remove('hidden');
-        } else {
-            themeToggleDarkIcon.classList.remove('hidden');
-        }
-
-        var themeToggleBtn = document.getElementById('theme-toggle');
-
-        themeToggleBtn.addEventListener('click', function () {
-
-            // toggle icons inside button
-            themeToggleDarkIcon.classList.toggle('hidden');
-            themeToggleLightIcon.classList.toggle('hidden');
-
-            // if set via local storage previously
-            if (localStorage.getItem('color-theme')) {
-                if (localStorage.getItem('color-theme') === 'light') {
-                    document.documentElement.classList.add('dark');
-                    localStorage.setItem('color-theme', 'dark');
-                } else {
-                    document.documentElement.classList.remove('dark');
-                    localStorage.setItem('color-theme', 'light');
-                }
-
-                // if NOT set via local storage previously
-            } else {
-                if (document.documentElement.classList.contains('dark')) {
-                    document.documentElement.classList.remove('dark');
-                    localStorage.setItem('color-theme', 'light');
-                } else {
-                    document.documentElement.classList.add('dark');
-                    localStorage.setItem('color-theme', 'dark');
-                }
-            }
-
-        });
-        </script>
-    </body>
-</html>

games/templates/cotton/button.html

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

games/templates/cotton/button_group.html

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

games/templates/cotton/button_group_button_sm.html

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

games/templates/cotton/button_group_sm.html

@@ -1,6 +0,0 @@
-<c-vars color="gray" />
-<div class="inline-flex rounded-md shadow-sm" role="group">
-    {% for button in buttons %}
-        <c-button-group-button-sm :href=button.href :text=button.text :color=button.color />
-    {% endfor %}
-</div>

games/templates/cotton/gamestatus.html

@@ -0,0 +1,16 @@
+<span class="relative ml-3 {{class}}">
+    <span class="rounded-xl w-2 h-2 absolute -left-3 top-2
+    {% if status == "u" %}
+    bg-gray-500
+    {% elif status == "p" %}
+    bg-orange-400
+    {% elif status == "f" %}
+    bg-green-500
+    {% elif status == "a" %}
+    bg-red-500
+    {% elif status == "r" %}
+    bg-purple-500
+    {% endif %}
+    ">&nbsp;</span>
+    {{ slot }}
+</span>

games/templates/cotton/icon/battlenet.html

@@ -0,0 +1,5 @@
+<c-svg title="Battle.net">
+<c-slot name="path">
+M 43.113281 22.152344 C 43.113281 22.152344 47.058594 22.351563 47.058594 20.03125 C 47.058594 16.996094 41.804688 14.261719 41.804688 14.261719 C 41.804688 14.261719 42.628906 12.515625 43.140625 11.539063 C 43.65625 10.5625 45.101563 6.753906 45.230469 5.886719 C 45.394531 4.792969 45.144531 4.449219 45.144531 4.449219 C 44.789063 6.792969 40.972656 13.539063 40.671875 13.769531 C 36.949219 12.023438 31.835938 11.539063 31.835938 11.539063 C 31.835938 11.539063 26.832031 1 22.125 1 C 17.457031 1 17.480469 10.023438 17.480469 10.023438 C 17.480469 10.023438 16.160156 7.464844 14.507813 7.464844 C 12.085938 7.464844 11.292969 11.128906 11.292969 15.097656 C 6.511719 15.097656 2.492188 16.164063 2.132813 16.265625 C 1.773438 16.371094 0.644531 17.191406 1.15625 17.089844 C 2.203125 16.753906 7.113281 15.992188 11.410156 16.367188 C 11.648438 20.140625 13.851563 25.054688 13.851563 25.054688 C 13.851563 25.054688 9.128906 31.894531 9.128906 36.78125 C 9.128906 38.066406 9.6875 40.417969 13.078125 40.417969 C 15.917969 40.417969 19.105469 38.710938 19.707031 38.363281 C 19.183594 39.113281 18.796875 40.535156 18.796875 41.191406 C 18.796875 41.726563 19.113281 43.246094 21.304688 43.246094 C 24.117188 43.246094 27.257813 41.089844 27.257813 41.089844 C 27.257813 41.089844 30.222656 46.019531 32.761719 48.28125 C 33.445313 48.890625 34.097656 49 34.097656 49 C 34.097656 49 31.578125 46.574219 28.257813 40.324219 C 31.34375 38.417969 34.554688 33.921875 34.554688 33.921875 C 34.554688 33.921875 34.933594 33.933594 37.863281 33.933594 C 42.453125 33.933594 48.972656 32.96875 48.972656 29.320313 C 48.972656 25.554688 43.113281 22.152344 43.113281 22.152344 Z M 43.625 19.886719 C 43.625 21.21875 42.359375 21.199219 42.359375 21.199219 L 41.394531 21.265625 C 41.394531 21.265625 39.566406 20.304688 38.460938 19.855469 C 38.460938 19.855469 40.175781 17.207031 40.578125 16.46875 C 40.882813 16.644531 43.625 18.363281 43.625 19.886719 Z M 24.421875 6.308594 C 26.578125 6.308594 29.65625 11.402344 29.65625 11.402344 C 29.65625 11.402344 24.851563 10.972656 20.898438 13.296875 C 21.003906 9.628906 22.238281 6.308594 24.421875 6.308594 Z M 15.871094 10.4375 C 16.558594 10.4375 17.230469 11.269531 17.507813 11.976563 C 17.507813 12.445313 17.75 15.171875 17.75 15.171875 L 13.789063 15.023438 C 13.789063 11.449219 15.1875 10.4375 15.871094 10.4375 Z M 15.464844 35.246094 C 13.300781 35.246094 12.851563 34.039063 12.851563 32.953125 C 12.851563 30.496094 14.8125 27.058594 14.8125 27.058594 C 14.8125 27.058594 17.011719 31.683594 20.851563 33.636719 C 18.945313 34.753906 17.375 35.246094 15.464844 35.246094 Z M 22.492188 40.089844 C 20.972656 40.089844 20.789063 39.105469 20.789063 38.878906 C 20.789063 38.171875 21.339844 37.335938 21.339844 37.335938 C 21.339844 37.335938 23.890625 35.613281 24.054688 35.429688 L 25.9375 38.945313 C 25.9375 38.945313 24.007813 40.089844 22.492188 40.089844 Z M 27.226563 38.171875 C 26.300781 36.554688 25.621094 34.867188 25.621094 34.867188 C 25.621094 34.867188 29.414063 35.113281 31.453125 33.007813 C 30.183594 33.578125 28.15625 34.300781 25.800781 34.082031 C 30.726563 29.742188 33.601563 26.597656 36.03125 23.34375 C 35.824219 23.09375 34.710938 22.316406 34.4375 22.1875 C 32.972656 23.953125 27.265625 30.054688 21.984375 33.074219 C 15.292969 29.425781 13.890625 18.691406 13.746094 16.460938 L 17.402344 16.8125 C 17.402344 16.8125 16.027344 19.246094 16.027344 21.039063 C 16.027344 22.828125 16.242188 22.925781 16.242188 22.925781 C 16.242188 22.925781 16.195313 19.800781 18.125 17.390625 C 19.59375 25.210938 21.125 29.21875 22.320313 31.605469 C 22.925781 31.355469 24.058594 30.851563 24.058594 30.851563 C 24.058594 30.851563 20.683594 21.121094 20.871094 14.535156 C 22.402344 13.71875 24.667969 12.875 27.226563 12.875 C 33.957031 12.875 39.367188 15.773438 39.367188 15.773438 L 37.25 18.730469 C 37.25 18.730469 35.363281 15.3125 32.699219 14.703125 C 34.105469 15.753906 35.679688 17.136719 36.496094 19.128906 C 30.917969 16.949219 24.1875 15.796875 22.027344 15.542969 C 21.839844 16.339844 21.863281 17.480469 21.863281 17.480469 C 21.863281 17.480469 30.890625 19.144531 37.460938 22.90625 C 37.414063 31.125 28.460938 37.4375 27.226563 38.171875 Z M 35.777344 32.027344 C 35.777344 32.027344 38.578125 28.347656 38.535156 23.476563 C 38.535156 23.476563 43.0625 26.28125 43.0625 29.015625 C 43.0625 32.074219 35.777344 32.027344 35.777344 32.027344 Z
+</c-slot>
+</c-svg>

games/templates/cotton/icon/bethesda.html

@@ -0,0 +1,5 @@
+<c-svg viewBox="0 0 20 20">
+<c-slot name="path">
+M2.069,11 L5,11 L5,9 L2.069,9 C2.252,7.542 2.828,6.208 3.688,5.102 L5.757,7.172 L7.171,5.757 L5.102,3.688 C6.208,2.828 8,2.252 9,2.069 L9,5 L11,5 L11,2.069 C12,2.252 13.791,2.828 14.897,3.688 L12.828,5.757 L14.242,7.172 L16.311,5.102 C17.171,6.208 17.747,7.542 17.93,9 L15,9 L15,11 L17.93,11 C17.747,12.458 17.171,13.792 16.311,14.898 L14.242,12.828 L12.828,14.243 L14.897,16.312 C13.791,17.172 12,17.748 11,17.931 L11,15 L9,15 L9,17.931 C8,17.748 6.208,17.172 5.102,16.312 L7.171,14.243 L5.757,12.828 L3.688,14.898 C2.828,13.792 2.252,12.458 2.069,11 M10,0 C4.477,0 0,4.477 0,10 C0,15.523 4.477,20 10,20 C15.522,20 20,15.523 20,10 C20,4.477 15.522,0 10,0
+</c-slot>
+</c-svg>

games/templates/cotton/icon/checkmark.html

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg"
+     x="0px"
+     y="0px"
+     viewBox="0 0 48 48"
+     class="text-black dark:text-white w-4 h-4">
+    <path fill="currentColor" d="M 43.470703 8.9863281 A 1.50015 1.50015 0 0 0 42.439453 9.4394531 L 16.5 35.378906 L 5.5605469 24.439453 A 1.50015 1.50015 0 1 0 3.4394531 26.560547 L 15.439453 38.560547 A 1.50015 1.50015 0 0 0 17.560547 38.560547 L 44.560547 11.560547 A 1.50015 1.50015 0 0 0 43.470703 8.9863281 z">
+    </path>
+</svg>

games/templates/cotton/icon/delete.html

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg"
+     x="0px"
+     y="0px"
+     viewBox="0 0 48 48"
+     class="text-black dark:text-white w-4 h-4">
+    <path fill="currentColor" d="M 24 4 C 20.491685 4 17.570396 6.6214322 17.080078 10 L 10.238281 10 A 1.50015 1.50015 0 0 0 9.9804688 9.9785156 A 1.50015 1.50015 0 0 0 9.7578125 10 L 6.5 10 A 1.50015 1.50015 0 1 0 6.5 13 L 8.6386719 13 L 11.15625 39.029297 C 11.427329 41.835926 13.811782 44 16.630859 44 L 31.367188 44 C 34.186411 44 36.570826 41.836168 36.841797 39.029297 L 39.361328 13 L 41.5 13 A 1.50015 1.50015 0 1 0 41.5 10 L 38.244141 10 A 1.50015 1.50015 0 0 0 37.763672 10 L 30.919922 10 C 30.429604 6.6214322 27.508315 4 24 4 z M 24 7 C 25.879156 7 27.420767 8.2681608 27.861328 10 L 20.138672 10 C 20.579233 8.2681608 22.120844 7 24 7 z M 11.650391 13 L 36.347656 13 L 33.855469 38.740234 C 33.730439 40.035363 32.667963 41 31.367188 41 L 16.630859 41 C 15.331937 41 14.267499 40.033606 14.142578 38.740234 L 11.650391 13 z M 20.476562 17.978516 A 1.50015 1.50015 0 0 0 19 19.5 L 19 34.5 A 1.50015 1.50015 0 1 0 22 34.5 L 22 19.5 A 1.50015 1.50015 0 0 0 20.476562 17.978516 z M 27.476562 17.978516 A 1.50015 1.50015 0 0 0 26 19.5 L 26 34.5 A 1.50015 1.50015 0 1 0 29 34.5 L 29 19.5 A 1.50015 1.50015 0 0 0 27.476562 17.978516 z">
+    </path>
+</svg>

games/templates/cotton/icon/eaorigin.html

@@ -0,0 +1,9 @@
+<c-svg viewbox="0 0 50 50">
+<g transform="scale(0.09765625)">
+<title>EA/Origin</title>
+<g>
+<path fill="currentColor" d="M299.125,126.274H126.628L97.876,183.93h172.499L299.125,126.274z" />
+<path fill="currentColor" d="M342.248,126.274L224.462,328.066h-105.8l32.862-57.653h61.347l28.758-57.658H69.125l-28.746,57.658H85.31L26.001,385.727h232.784l83.463-153.654l18.169,38.342h-18.169l-28.75,57.654h75.67l28.75,57.658h68.081L342.248,126.274z" />
+</g>
+</g>
+</c-svg>

games/templates/cotton/icon/edit.html

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg"
+     x="0px"
+     y="0px"
+     viewBox="0 0 48 48"
+     class="text-black dark:text-white w-4 h-4">
+    <path fill="currentColor" d="M 40.5 6 C 40.11625 6 39.732453 6.1464531 39.439453 6.4394531 L 21.462891 24.417969 L 20 28 L 23.582031 26.537109 L 41.560547 8.5605469 C 42.145547 7.9745469 42.145547 7.0254531 41.560547 6.4394531 C 41.267547 6.1464531 40.88375 6 40.5 6 z M 12.5 7 C 9.4802259 7 7 9.4802259 7 12.5 L 7 35.5 C 7 38.519774 9.4802259 41 12.5 41 L 35.5 41 C 38.519774 41 41 38.519774 41 35.5 L 41 18.5 A 1.50015 1.50015 0 1 0 38 18.5 L 38 35.5 C 38 36.898226 36.898226 38 35.5 38 L 12.5 38 C 11.101774 38 10 36.898226 10 35.5 L 10 12.5 C 10 11.101774 11.101774 10 12.5 10 L 29.5 10 A 1.50015 1.50015 0 1 0 29.5 7 L 12.5 7 z">
+    </path>
+</svg>

games/templates/cotton/icon/egs.html

@@ -0,0 +1,6 @@
+<c-vars title="Epic Games Store" />
+<c-svg :title=title viewbox="0 0 50 50">
+<c-slot name="path">
+M 10 3 C 6.69 3 4 5.69 4 9 L 4 41.240234 L 25 47.539062 L 46 41.240234 L 46 9 C 46 5.69 43.31 3 40 3 L 10 3 z M 11 8 L 15 8 L 15 11 L 11 11 L 11 18 L 14 18 L 14 21 L 11 21 L 11 28 L 15 28 L 15 31 L 11 31 C 9.34 31 8 29.66 8 28 L 8 11 C 8 9.34 9.34 8 11 8 z M 17 8 L 23 8 C 24.66 8 26 9.34 26 11 L 26 18 C 26 19.66 24.66 21 23 21 L 20 21 L 20 31 L 17 31 L 17 8 z M 28 8 L 31 8 L 31 31 L 28 31 L 28 8 z M 36 8 L 39 8 C 40.66 8 42 9.34 42 11 L 42 15 L 39 15 L 39 11 L 36 11 L 36 28 L 39 28 L 39 24 L 42 24 L 42 28 C 42 29.66 40.66 31 39 31 L 36 31 C 34.34 31 33 29.66 33 28 L 33 11 C 33 9.34 34.34 8 36 8 z M 20 11 L 20 18 L 23 18 L 23 11 L 20 11 z M 9 34 L 13 34 C 13.55 34 14 34.45 14 35 L 14 36 L 13 36 L 13 35.25 C 13 35.11 12.89 35 12.75 35 L 9.25 35 C 9.11 35 9 35.11 9 35.25 L 9 38.75 C 9 38.89 9.11 39 9.25 39 L 12.75 39 C 12.89 39 13 38.89 13 38.75 L 13 38 L 12 38 L 12 37 L 14 37 L 14 39 C 14 39.55 13.55 40 13 40 L 9 40 C 8.45 40 8 39.55 8 39 L 8 35 C 8 34.45 8.45 34 9 34 z M 18 34 L 19 34 L 22 40 L 21 40 L 20.5 39 L 16.5 39 L 16 40 L 15 40 L 18 34 z M 23 34 L 24 34 L 26 38 L 28 34 L 29 34 L 29 40 L 28 40 L 28 36 L 26.5 39 L 25.5 39 L 24 36 L 24 40 L 23 40 L 23 34 z M 30 34 L 35 34 L 35 35 L 31 35 L 31 36.5 L 33 36.5 L 33 37.5 L 31 37.5 L 31 39 L 35 39 L 35 40 L 30 40 L 30 34 z M 37 34 L 41 34 C 41.55 34 42 34.45 42 35 L 42 35.5 L 41 35.5 L 41 35.25 C 41 35.11 40.89 35 40.75 35 L 37.25 35 C 37.11 35 37 35.11 37 35.25 L 37 36.25 C 37 36.39 37.11 36.5 37.25 36.5 L 41 36.5 C 41.55 36.5 42 36.95 42 37.5 L 42 39 C 42 39.55 41.55 40 41 40 L 37 40 C 36.45 40 36 39.55 36 39 L 36 38.5 L 37 38.5 L 37 38.75 C 37 38.89 37.11 39 37.25 39 L 40.75 39 C 40.89 39 41 38.89 41 38.75 L 41 37.75 C 41 37.61 40.89 37.5 40.75 37.5 L 37 37.5 C 36.45 37.5 36 37.05 36 36.5 L 36 35 C 36 34.45 36.45 34 37 34 z M 18.5 35 L 17 38 L 20 38 L 18.5 35 z
+</c-slot>
+</c-svg>

games/templates/cotton/icon/eject.html

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg"
+     x="0px"
+     y="0px"
+     viewBox="0 0 48 48"
+     class="text-black dark:text-white w-4 h-4">
+    <path fill="currentColor" d="M 24 5.0507812 C 22.945045 5.0507812 21.890232 5.4877258 21.160156 6.3613281 L 7.0566406 23.257812 C 5.2226244 25.45627 6.8812774 29 9.7441406 29 L 38.255859 29 C 41.119312 29 42.778426 25.453888 40.943359 23.255859 L 26.839844 6.3613281 C 26.109768 5.4877258 25.054955 5.0507812 24 5.0507812 z M 24 8.015625 C 24.194045 8.015625 24.387185 8.105759 24.537109 8.2851562 L 38.638672 25.179688 C 38.977605 25.585659 38.784407 26 38.255859 26 L 9.7441406 26 C 9.2150038 26 9.0213443 25.58723 9.3613281 25.179688 L 23.462891 8.2851562 C 23.612815 8.1057586 23.805955 8.015625 24 8.015625 z M 10.5 33 C 8.0324991 33 6 35.032499 6 37.5 L 6 38.5 C 6 40.967501 8.0324991 43 10.5 43 L 37.5 43 C 39.967501 43 42 40.967501 42 38.5 L 42 37.5 C 42 35.032499 39.967501 33 37.5 33 L 10.5 33 z M 10.5 36 L 37.5 36 C 38.346499 36 39 36.653501 39 37.5 L 39 38.5 C 39 39.346499 38.346499 40 37.5 40 L 10.5 40 C 9.6535009 40 9 39.346499 9 38.5 L 9 37.5 C 9 36.653501 9.6535009 36 10.5 36 z">
+    </path>
+</svg>

games/templates/cotton/icon/emulated.html

@@ -0,0 +1,6 @@
+<c-vars title="Emulated" />
+<c-svg :title=title viewbox="0 0 48 48">
+<c-slot name="path">
+    M 8.5 5 C 6.0324991 5 4 7.0324991 4 9.5 L 4 30.5 C 4 32.967501 6.0324991 35 8.5 35 L 17 35 L 17 40 L 13.5 40 A 1.50015 1.50015 0 1 0 13.5 43 L 18.253906 43 A 1.50015 1.50015 0 0 0 18.740234 43 L 29.253906 43 A 1.50015 1.50015 0 0 0 29.740234 43 L 34.5 43 A 1.50015 1.50015 0 1 0 34.5 40 L 31 40 L 31 35 L 39.5 35 C 41.967501 35 44 32.967501 44 30.5 L 44 9.5 C 44 7.0324991 41.967501 5 39.5 5 L 8.5 5 z M 8.5 8 L 39.5 8 C 40.346499 8 41 8.6535009 41 9.5 L 41 30.5 C 41 31.346499 40.346499 32 39.5 32 L 29.746094 32 A 1.50015 1.50015 0 0 0 29.259766 32 L 18.746094 32 A 1.50015 1.50015 0 0 0 18.259766 32 L 8.5 32 C 7.6535009 32 7 31.346499 7 30.5 L 7 9.5 C 7 8.6535009 7.6535009 8 8.5 8 z M 17.5 12 C 16.136406 12 15 13.136406 15 14.5 L 15 25.5 C 15 26.863594 16.136406 28 17.5 28 L 30.5 28 C 31.863594 28 33 26.863594 33 25.5 L 33 14.5 C 33 13.136406 31.863594 12 30.5 12 L 17.5 12 z M 18 18 L 30 18 L 30 25 L 18 25 L 18 18 z M 20 35 L 28 35 L 28 40 L 20 40 L 20 35 z
+</c-slot>
+</c-svg>

games/templates/cotton/icon/end.html

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg"
+     x="0px"
+     y="0px"
+     viewBox="0 0 48 48"
+     class="text-black dark:text-white w-4 h-4">
+    <path fill="currentColor" d="M 35.5 6 C 33.585045 6 32 7.5850452 32 9.5 L 32 19.365234 L 11.339844 6.6074219 C 9.0734225 5.2081236 6 6.9228749 6 9.5859375 L 6 38.414062 C 6 41.077126 9.0734225 42.791876 11.339844 41.392578 L 32 28.634766 L 32 38.5 C 32 40.414955 33.585045 42 35.5 42 L 38.5 42 C 40.414955 42 42 40.414955 42 38.5 L 42 9.5 C 42 7.5850452 40.414955 6 38.5 6 L 35.5 6 z M 35.5 9 L 38.5 9 C 38.795045 9 39 9.2049548 39 9.5 L 39 38.5 C 39 38.795045 38.795045 39 38.5 39 L 35.5 39 C 35.204955 39 35 38.795045 35 38.5 L 35 9.5 C 35 9.2049548 35.204955 9 35.5 9 z M 9.4765625 9.0566406 C 9.5668015 9.0647233 9.6637771 9.0984812 9.7636719 9.1601562 L 32 22.892578 L 32 25.107422 L 9.7636719 38.839844 C 9.364093 39.086546 9 38.883001 9 38.414062 L 9 9.5859375 C 9 9.3514688 9.091623 9.1841053 9.2324219 9.1054688 C 9.3028213 9.0661502 9.3863235 9.048558 9.4765625 9.0566406 z">
+    </path>
+</svg>

games/templates/cotton/icon/finish.html

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg"
+     x="0px"
+     y="0px"
+     viewBox="0 0 48 48"
+     class="text-black dark:text-white w-4 h-4">
+    <path fill="currentColor" d="M 7.4765625 4.9785156 A 1.50015 1.50015 0 0 0 6 6.5 L 6 31.5 L 6 43.5 A 1.50015 1.50015 0 1 0 9 43.5 L 9 33 L 40.5 33 C 41.329 33 42 32.328 42 31.5 L 42 6.5 C 42 5.672 41.329 5 40.5 5 L 7.7460938 5 A 1.50015 1.50015 0 0 0 7.4765625 4.9785156 z M 16 8 L 24 8 L 24 15 L 32 15 L 32 8 L 39 8 L 39 15 L 32 15 L 32 23 L 39 23 L 39 30 L 32 30 L 32 23 L 24 23 L 24 30 L 16 30 L 16 23 L 9 23 L 9 15 L 16 15 L 16 8 z M 16 15 L 16 23 L 24 23 L 24 15 L 16 15 z">
+    </path>
+</svg>

games/templates/cotton/icon/gog.html

@@ -0,0 +1,5 @@
+<c-svg title="GOG.com" viewbox="0 0 50 50">
+<c-slot name="path">
+M 5.75 6 C 3.703125 6 2 7.703125 2 9.75 L 2 16.25 C 2 18.296875 3.703125 20 5.75 20 L 12 20 L 12 22 L 4 22 C 3.277344 21.988281 2.609375 22.367188 2.246094 22.992188 C 1.878906 23.613281 1.878906 24.386719 2.246094 25.007813 C 2.609375 25.632813 3.277344 26.011719 4 26 L 12.25 26 C 14.296875 26 16 24.296875 16 22.25 L 16 15.75 C 16.003906 15.6875 16.003906 15.625 16 15.5625 L 16 9.75 C 16 7.703125 14.296875 6 12.25 6 Z M 21.75 6 C 19.703125 6 18 7.703125 18 9.75 L 18 16.25 C 18 18.296875 19.703125 20 21.75 20 L 28.25 20 C 30.296875 20 32 18.296875 32 16.25 L 32 9.75 C 32 7.703125 30.296875 6 28.25 6 Z M 37.75 6 C 35.703125 6 34 7.703125 34 9.75 L 34 16.25 C 34 18.296875 35.703125 20 37.75 20 L 44 20 L 44 22 L 36 22 C 35.277344 21.988281 34.609375 22.367188 34.246094 22.992188 C 33.878906 23.613281 33.878906 24.386719 34.246094 25.007813 C 34.609375 25.632813 35.277344 26.011719 36 26 L 44.25 26 C 46.296875 26 48 24.296875 48 22.25 L 48 15.75 C 48.003906 15.6875 48.003906 15.625 48 15.5625 L 48 9.75 C 48 7.703125 46.296875 6 44.25 6 Z M 6 10 L 12 10 L 12 15.59375 C 11.996094 15.644531 11.996094 15.699219 12 15.75 L 12 16 L 6 16 Z M 22 10 L 28 10 L 28 16 L 22 16 Z M 38 10 L 44 10 L 44 15.59375 C 43.996094 15.644531 43.996094 15.699219 44 15.75 L 44 16 L 38 16 Z M 5.75 30 C 3.703125 30 2 31.703125 2 33.75 L 2 40.25 C 2 42.296875 3.703125 44 5.75 44 L 12 44 C 12.722656 44.011719 13.390625 43.632813 13.753906 43.007813 C 14.121094 42.386719 14.121094 41.613281 13.753906 40.992188 C 13.390625 40.367188 12.722656 39.988281 12 40 L 6 40 L 6 34 L 12 34 C 12.722656 34.011719 13.390625 33.632813 13.753906 33.007813 C 14.121094 32.386719 14.121094 31.613281 13.753906 30.992188 C 13.390625 30.367188 12.722656 29.988281 12 30 Z M 19.75 30 C 17.703125 30 16 31.703125 16 33.75 L 16 40.25 C 16 42.296875 17.703125 44 19.75 44 L 26.25 44 C 28.296875 44 29.996094 42.296875 30 40.25 L 30 33.75 C 30 31.703125 28.296875 30 26.25 30 Z M 38.65625 30 C 38.65625 30 37.933594 30 37.15625 30.03125 C 36.769531 30.046875 36.355469 30.066406 36 30.09375 C 35.824219 30.105469 35.667969 30.136719 35.5 30.15625 C 35.332031 30.175781 35.242188 30.152344 34.8125 30.3125 C 33.738281 30.714844 32.972656 31.429688 32.4375 32.4375 C 32.5 32.320313 32.355469 32.496094 32.21875 32.90625 C 32.082031 33.316406 32.078125 33.566406 32.0625 33.875 C 32.03125 34.496094 32.011719 35.507813 32 37.8125 C 31.992188 39.167969 32 40.203125 32 40.90625 C 32 41.257813 31.996094 41.515625 32 41.71875 C 32 41.820313 31.996094 41.914063 32 42 C 32 42.042969 31.992188 42.085938 32 42.15625 C 32.007813 42.226563 31.914063 42.171875 32.125 42.71875 C 32.453125 43.707031 33.484375 44.277344 34.492188 44.035156 C 35.503906 43.789063 36.160156 42.808594 36 41.78125 C 36 41.777344 36 41.722656 36 41.71875 C 36 41.703125 36 41.707031 36 41.6875 C 35.996094 41.527344 36 41.25 36 40.90625 C 36 40.21875 35.992188 39.199219 36 37.84375 C 36.011719 35.640625 36.011719 34.671875 36.03125 34.25 C 36.101563 34.183594 36.167969 34.117188 36.1875 34.09375 C 36.230469 34.089844 36.257813 34.097656 36.3125 34.09375 C 36.585938 34.074219 36.949219 34.046875 37.3125 34.03125 C 37.667969 34.015625 37.75 34.003906 38 34 L 38 42 C 37.988281 42.722656 38.367188 43.390625 38.992188 43.753906 C 39.613281 44.121094 40.386719 44.121094 41.007813 43.753906 C 41.632813 43.390625 42.011719 42.722656 42 42 L 42 34 C 42.800781 34 43.28125 34 44 34 L 44 42 C 43.988281 42.722656 44.367188 43.390625 44.992188 43.753906 C 45.613281 44.121094 46.386719 44.121094 47.007813 43.753906 C 47.632813 43.390625 48.011719 42.722656 48 42 L 48 30 L 46 30 C 46 30 39.59375 29.996094 38.6875 30 Z M 20 34 L 26 34 L 26 40 L 20 40 Z
+</c-slot>
+</c-svg>