Always return timedelta in update_game_playtime

Prevents actually finding any new prices

.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

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

common/components.py

@@ -9,7 +9,7 @@ from django.urls import NoReverseMatch, reverse
 from django.utils.safestring import SafeText, mark_safe
 
 from common.utils import truncate
-from games.models import Purchase
+from games.models import Game, Purchase, Session
 
 HTMLAttribute = tuple[str, str | int | bool]
 HTMLTag = str
@@ -32,7 +32,7 @@ def Component(
         attributesList = [f'{name}="{value}"' for name, value in attributes]
         # make attribute list into a string
         # and insert space between tag and attribute list
-        attributesBlob = f" {" ".join(attributesList)}"
+        attributesBlob = f" {' '.join(attributesList)}"
     tag: str = ""
     if tag_name != "":
         tag = f"<{tag_name}{attributesBlob}>{childrenBlob}</{tag_name}>"
@@ -188,49 +188,28 @@ def Icon(
     return result
 
 
-def LinkedNameWithPlatformIcon(name: str, game_id: int, platform: str) -> SafeText:
-    link = reverse("view_game", args=[int(game_id)])
-    a_content = Div(
-        [("class", "inline-flex gap-2 items-center")],
-        [
-            Icon(
-                platform.icon,
-                [("title", platform.name)],
-            ),
-            PopoverTruncated(name),
-        ],
-    )
-
-    return mark_safe(
-        A(
-            url=link,
-            children=[a_content],
-        ),
-    )
-
-
 def LinkedPurchase(purchase: Purchase) -> SafeText:
     link = reverse("view_purchase", args=[int(purchase.id)])
     link_content = ""
     popover_content = ""
-    edition_count = purchase.editions.count()
+    game_count = purchase.games.count()
     popover_if_not_truncated = False
-    if edition_count == 1:
-        link_content += purchase.editions.first().name
+    if game_count == 1:
+        link_content += purchase.games.first().name
         popover_content = link_content
-    if edition_count > 1:
+    if game_count > 1:
         if purchase.name:
             link_content += f"{purchase.name}"
             popover_content += f"<h1>{purchase.name}</h1><br>"
         else:
-            link_content += f"{edition_count} games"
+            link_content += f"{game_count} games"
             popover_if_not_truncated = True
         popover_content += f"""
         <ul class="list-disc list-inside">
-            {"".join(f"<li>{edition.name}</li>" for edition in purchase.editions.all())}
+            {"".join(f"<li>{game.name}</li>" for game in purchase.games.all())}
         </ul>
         """
-    icon = purchase.platform.icon if edition_count == 1 else "unspecified"
+    icon = purchase.platform.icon if game_count == 1 else "unspecified"
     if link_content == "":
         raise ValueError("link_content is empty!!")
     a_content = Div(
@@ -250,19 +229,54 @@ def LinkedPurchase(purchase: Purchase) -> SafeText:
     return mark_safe(A(url=link, children=[a_content]))
 
 
-def NameWithPlatformIcon(name: str, platform: str) -> SafeText:
+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(content)
+    return mark_safe(
+        A(
+            url=link,
+            children=[content],
+        )
+        if create_link
+        else content,
+    )
 
 
 def PurchasePrice(purchase) -> str:

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)

common/utils.py

@@ -1,5 +1,13 @@
+import operator
+from dataclasses import dataclass
 from datetime import date
-from typing import Any, Generator, TypeVar
+from functools import reduce, wraps
+from typing import Any, Callable, Generator, Literal, TypeVar
+from urllib.parse import urlencode
+
+from django.db.models import Q
+from django.http import HttpRequest
+from django.shortcuts import redirect
 
 
 def safe_division(numerator: int | float, denominator: int | float) -> int | float:
@@ -36,7 +44,7 @@ def safe_getattr(obj: object, attr_chain: str, default: Any | None = None) -> ob
 
 def truncate_(input_string: str, length: int = 30, ellipsis: str = "…") -> str:
     return (
-        (f"{input_string[:length-len(ellipsis)].rstrip()}{ellipsis}")
+        (f"{input_string[: length - len(ellipsis)].rstrip()}{ellipsis}")
         if len(input_string) > length
         else input_string
     )
@@ -50,12 +58,12 @@ def truncate(
         raise ValueError("Length cannot be shorter than the length of endpart.")
 
     if len(input_string) > max_content_length:
-        return f"{input_string[:max_content_length - len(ellipsis)].rstrip()}{ellipsis}{endpart}"
+        return f"{input_string[: max_content_length - len(ellipsis)].rstrip()}{ellipsis}{endpart}"
 
     return (
         f"{input_string}{endpart}"
         if len(input_string) + len(endpart) <= length
-        else f"{input_string[:length - len(ellipsis) - len(endpart)].rstrip()}{ellipsis}{endpart}"
+        else f"{input_string[: length - len(ellipsis) - len(endpart)].rstrip()}{ellipsis}{endpart}"
     )
 
 
@@ -81,3 +89,79 @@ def generate_split_ranges(
 
 def format_float_or_int(number: int | float):
     return int(number) if float(number).is_integer() else f"{number:03.2f}"
+
+
+OperatorType = Literal["|", "&"]
+
+
+@dataclass
+class FilterEntry:
+    condition: Q
+    operator: OperatorType = "&"
+
+
+def build_dynamic_filter(
+    filters: list[FilterEntry | Q], default_operator: OperatorType = "&"
+):
+    """
+    Constructs a Django Q filter from a list of filter conditions.
+
+    Args:
+        filters (list): A list where each item is either:
+            - A Q object (default AND logic applied)
+            - A tuple of (Q object, operator) where operator is "|" (OR) or "&" (AND)
+
+    Returns:
+        Q: A combined Q object that can be passed to Django's filter().
+    """
+    op_map: dict[OperatorType, Callable[[Q, Q], Q]] = {
+        "|": operator.or_,
+        "&": operator.and_,
+    }
+
+    # Convert all plain Q objects into (Q, "&") for default AND behavior
+    processed_filters = [
+        FilterEntry(f, default_operator) if isinstance(f, Q) else f for f in filters
+    ]
+
+    # Reduce with dynamic operators
+    return reduce(
+        lambda combined_filters, filter: op_map[filter.operator](
+            combined_filters, filter.condition
+        ),
+        processed_filters,
+        Q(),
+    )
+
+
+def redirect_to(default_view: str, *default_args):
+    """
+    A decorator that redirects the user back to the referring page or a default view if no 'next' parameter is provided.
+
+    :param default_view: The name of the default view to redirect to if 'next' is missing.
+    :param default_args: Any arguments required for the default view.
+    """
+
+    def decorator(view_func):
+        @wraps(view_func)
+        def wrapped_view(request: HttpRequest, *args, **kwargs):
+            next_url = request.GET.get("next")
+            if not next_url:
+                from django.urls import (
+                    reverse,  # Import inside function to avoid circular imports
+                )
+
+                next_url = reverse(default_view, args=default_args)
+
+            response = view_func(
+                request, *args, **kwargs
+            )  # Execute the original view logic
+            return redirect(next_url)
+
+        return wrapped_view
+
+    return decorator
+
+
+def add_next_param_to_url(url: str, nexturl: str) -> str:
+    return f"{url}?{urlencode({'next': nexturl})}"

contrib/scripts/get_exchange_rates_since_1990.py

@@ -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()

games/admin.py

@@ -2,7 +2,6 @@ from django.contrib import admin
 
 from games.models import (
     Device,
-    Edition,
     ExchangeRate,
     Game,
     Platform,
@@ -15,6 +14,5 @@ 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,9 +1,10 @@
-from datetime import timedelta
+# from datetime import timedelta
 
 from django.apps import AppConfig
 from django.core.management import call_command
 from django.db.models.signals import post_migrate
-from django.utils.timezone import now
+
+# from django.utils.timezone import now
 
 
 class GamesConfig(AppConfig):
@@ -11,20 +12,32 @@ class GamesConfig(AppConfig):
     name = "games"
 
     def ready(self):
+        import games.signals  # noqa: F401
+
         post_migrate.connect(schedule_tasks, sender=self)
 
 
 def schedule_tasks(sender, **kwargs):
-    from django_q.models import Schedule
-    from django_q.tasks import schedule
+    # 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),
-        )
+    # 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
 

games/fixtures/exchangerates.yaml

@@ -110,3 +110,395 @@
     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

@@ -2,7 +2,15 @@ from django import forms
 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 +19,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(
-    #     queryset=Purchase.objects.filter(date_refunded=None).order_by("edition__name")
-    # )
-    purchase = forms.ModelChoiceField(
-        queryset=Purchase.objects.all(),
+    game = SingleGameChoiceField(
+        queryset=Game.objects.order_by("sort_name"),
         widget=forms.Select(attrs={"autofocus": "autofocus"}),
     )
 
+    duration_manual = forms.DurationField(
+        required=False,
+        widget=forms.TextInput(
+            attrs={"x-mask": "99:99:99", "placeholder": "HH:MM:SS", "x-data": ""}
+        ),
+        label="Manual duration",
+    )
     device = forms.ModelChoiceField(queryset=Device.objects.order_by("name"))
 
+    mark_as_played = forms.BooleanField(
+        required=False,
+        initial={"mark_as_played": True},
+        label="Set game status to Played if Unplayed",
+    )
+
     class Meta:
         widgets = {
             "timestamp_start": custom_datetime_widget,
@@ -29,18 +57,27 @@ class SessionForm(forms.ModelForm):
         }
         model = Session
         fields = [
-            "purchase",
+            "game",
             "timestamp_start",
             "timestamp_end",
             "duration_manual",
+            "emulated",
             "device",
             "note",
+            "mark_as_played",
         ]
 
-
-class EditionChoiceField(forms.ModelMultipleChoiceField):
-    def label_from_instance(self, obj) -> str:
-        return f"{obj.sort_name} ({obj.platform}, {obj.year_released})"
+    def save(self, commit=True):
+        session = super().save(commit=False)
+        if self.cleaned_data.get("mark_as_played"):
+            game_instance = session.game
+            if game_instance.status == "u":
+                game_instance.status = "p"
+            if commit:
+                game_instance.save()
+        if commit:
+            session.save()
+        return session
 
 
 class IncludePlatformSelect(forms.SelectMultiple):
@@ -56,19 +93,19 @@ class PurchaseForm(forms.ModelForm):
         super().__init__(*args, **kwargs)
 
         # Automatically update related_purchase <select/>
-        # to only include purchases of the selected edition.
-        related_purchase_by_edition_url = reverse("related_purchase_by_edition")
-        self.fields["editions"].widget.attrs.update(
+        # to only include purchases of the selected game.
+        related_purchase_by_game_url = reverse("related_purchase_by_game")
+        self.fields["games"].widget.attrs.update(
             {
                 "hx-trigger": "load, click",
-                "hx-get": related_purchase_by_edition_url,
+                "hx-get": related_purchase_by_game_url,
                 "hx-target": "#id_related_purchase",
                 "hx-swap": "outerHTML",
             }
         )
 
-    editions = EditionChoiceField(
-        queryset=Edition.objects.order_by("sort_name"),
+    games = MultipleGameChoiceField(
+        queryset=Game.objects.order_by("sort_name"),
         widget=IncludePlatformSelect(attrs={"autoselect": "autoselect"}),
     )
     platform = forms.ModelChoiceField(queryset=Platform.objects.order_by("name"))
@@ -77,21 +114,29 @@ class PurchaseForm(forms.ModelForm):
         required=False,
     )
 
+    price_currency = forms.CharField(
+        widget=forms.TextInput(
+            attrs={
+                "x-mask": "aaa",
+                "placeholder": "CZK",
+                "x-data": "",
+                "class": "uppercase",
+            }
+        ),
+        label="Currency",
+    )
+
     class Meta:
         widgets = {
             "date_purchased": custom_date_widget,
             "date_refunded": custom_date_widget,
-            "date_finished": custom_date_widget,
-            "date_dropped": custom_date_widget,
         }
         model = Purchase
         fields = [
-            "editions",
+            "games",
             "platform",
             "date_purchased",
             "date_refunded",
-            "date_finished",
-            "date_dropped",
             "infinite",
             "price",
             "price_currency",
@@ -138,24 +183,23 @@ class GameModelChoiceField(forms.ModelChoiceField):
         return obj.sort_name
 
 
-class EditionForm(forms.ModelForm):
-    game = GameModelChoiceField(
-        queryset=Game.objects.order_by("sort_name"),
-        widget=IncludeNameSelect(attrs={"autofocus": "autofocus"}),
-    )
+class GameForm(forms.ModelForm):
     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}
 
 
@@ -175,3 +219,37 @@ 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"}),
+    )
+
+    class Meta:
+        model = PlayEvent
+        fields = [
+            "game",
+            "started",
+            "ended",
+            "note",
+        ]
+        widgets = {
+            "started": custom_date_widget,
+            "ended": custom_date_widget,
+        }
+
+
+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/migrations/0001_initial.py

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

games/migrations/0002_alter_session_duration_manual.py

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

games/migrations/0002_purchase_price_per_game.py

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

games/migrations/0003_alter_session_duration_manual_and_more.py

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

games/migrations/0003_purchase_updated_at.py

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

games/migrations/0004_alter_session_duration_manual.py

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

games/migrations/0004_purchase_num_purchases.py

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

games/migrations/0005_auto_20230109_1843.py

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

games/migrations/0005_game_mastered_game_status.py

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

games/migrations/0006_alter_game_sort_name_alter_game_wikidata_and_more.py

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

games/migrations/0006_auto_20230109_1904.py

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

games/migrations/0007_alter_purchase_game_alter_purchase_platform_and_more.py

@@ -1,35 +0,0 @@
-# Generated by Django 4.1.5 on 2023-01-19 18:30
-
-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/migrations/0037_platform_icon.py

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

games/migrations/0038_alter_purchase_price.py

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

games/migrations/0039_alter_device_type.py

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

games/migrations/0040_migrate_device_types.py

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

games/migrations/0041_purchase_converted_currency_purchase_converted_price_and_more.py

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

games/migrations/0042_purchase_editions_temp.py

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

games/migrations/0043_auto_20250107_2117.py

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

games/migrations/0044_auto_20250107_2132.py

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

games/migrations/0045_alter_purchase_editions.py

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

games/migrations/0046_game_platform_alter_game_unique_together.py

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

games/migrations/0047_auto_20250119_2129.py

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

games/models.py

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

games/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=instance.updated_at,
+        )
+    else:
+        logger.info("[game_status_changed]: Status has not changed")

games/static/base.css

@@ -1299,6 +1299,14 @@ input:checked + .toggle-bg {
   bottom: 0px;
 }
 
+.-left-3 {
+  left: -0.75rem;
+}
+
+.-left-\[1px\] {
+  left: -1px;
+}
+
 .bottom-0 {
   bottom: 0px;
 }
@@ -1335,10 +1343,18 @@ input:checked + .toggle-bg {
   top: 0px;
 }
 
+.top-2 {
+  top: 0.5rem;
+}
+
 .top-3 {
   top: 0.75rem;
 }
 
+.top-\[100\%\] {
+  top: 100%;
+}
+
 .z-10 {
   z-index: 10;
 }
@@ -1415,6 +1431,10 @@ input:checked + .toggle-bg {
   margin-inline-end: 0.5rem;
 }
 
+.ml-3 {
+  margin-left: 0.75rem;
+}
+
 .mr-4 {
   margin-right: 1rem;
 }
@@ -1488,6 +1508,10 @@ input:checked + .toggle-bg {
   height: 3rem;
 }
 
+.h-2 {
+  height: 0.5rem;
+}
+
 .h-2\.5 {
   height: 0.625rem;
 }
@@ -1524,6 +1548,10 @@ input:checked + .toggle-bg {
   width: 2.5rem;
 }
 
+.w-2 {
+  width: 0.5rem;
+}
+
 .w-2\.5 {
   width: 0.625rem;
 }
@@ -1532,6 +1560,10 @@ input:checked + .toggle-bg {
   width: 6rem;
 }
 
+.w-3 {
+  width: 0.75rem;
+}
+
 .w-4 {
   width: 1rem;
 }
@@ -1556,6 +1588,10 @@ input:checked + .toggle-bg {
   width: 20rem;
 }
 
+.w-auto {
+  width: auto;
+}
+
 .w-full {
   width: 100%;
 }
@@ -1576,6 +1612,10 @@ input:checked + .toggle-bg {
   max-width: 24rem;
 }
 
+.max-w-xl {
+  max-width: 36rem;
+}
+
 .max-w-xs {
   max-width: 20rem;
 }
@@ -1704,6 +1744,10 @@ input:checked + .toggle-bg {
   justify-content: space-between;
 }
 
+.gap-1 {
+  gap: 0.25rem;
+}
+
 .gap-2 {
   gap: 0.5rem;
 }
@@ -1716,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));
@@ -1787,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;
@@ -1807,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;
 }
@@ -1815,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));
@@ -1880,15 +1957,29 @@ 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));
@@ -1899,6 +1990,21 @@ input:checked + .toggle-bg {
   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));
@@ -2030,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;
 }
@@ -2177,6 +2287,11 @@ input:checked + .toggle-bg {
   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));
@@ -2249,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;
@@ -2349,10 +2470,9 @@ input:checked + .toggle-bg {
   transition: all 0.2s ease-out;
 } */
 
-form label:is(.dark *) {
-  --tw-text-opacity: 1;
-  color: rgb(148 163 184 / var(--tw-text-opacity));
-}
+/* form label {
+  @apply dark:text-slate-400;
+} */
 
 .responsive-table {
   margin-left: auto;
@@ -2391,25 +2511,25 @@ form label:is(.dark *) {
   border-left-color: rgb(100 116 139 / var(--tw-border-opacity));
 }
 
-form input:is(.dark *),
-select:is(.dark *),
-textarea:is(.dark *) {
-  border-width: 1px;
-  --tw-border-opacity: 1;
-  border-color: rgb(15 23 42 / var(--tw-border-opacity));
-  --tw-bg-opacity: 1;
-  background-color: rgb(100 116 139 / var(--tw-bg-opacity));
-  --tw-text-opacity: 1;
-  color: rgb(241 245 249 / var(--tw-text-opacity));
+/* 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 {
+  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 {
@@ -2425,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;
@@ -2548,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));

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") {
-    var idEditionValue = document.getElementById("id_edition").value;
+  if (event.target.id === "id_games") {
+    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

@@ -1,4 +1,11 @@
 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
 
@@ -8,8 +15,8 @@ currency_to = currency_to.upper()
 
 
 def save_converted_info(purchase, converted_price, converted_currency):
-    print(
-        f"Changing converted price of {purchase} to {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
@@ -18,8 +25,10 @@ def save_converted_info(purchase, converted_price, converted_currency):
 
 def convert_prices():
     purchases = Purchase.objects.filter(
-        converted_price__isnull=True, converted_currency__isnull=True
+        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:
@@ -27,31 +36,59 @@ def convert_prices():
             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}.json"
+                    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()
-                rate = data[currency_from].get(currency_to)
+                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=rate,
+                        rate=floatformat(rate, 2),
                     )
+                else:
+                    logger.info("[convert_prices]: Could not get an exchange rate.")
             except requests.RequestException as e:
-                print(
-                    f"Failed to fetch exchange rate for {currency_from}->{currency_to} in {year}: {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, purchase.price * exchange_rate.rate, currency_to
+                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_edition.html

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

games/templates/add_game.html

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

games/templates/cotton/button.html

@@ -1,6 +1,6 @@
-<c-vars color="blue" size="base" />
-<button type="button"
+<c-vars color="blue" size="base" type="button" />
+<button type="{{ type }}" 
         title="{{ title }}"
-        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 %} ">
+        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/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/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/layouts/add.html

@@ -3,19 +3,18 @@
 {% if form_content %}
     {{ form_content }}
 {% else %}
-    <form method="post" enctype="multipart/form-data">
-        <table class="mx-auto">
+<div class="max-width-container">
+    <div class="form-container max-w-xl mx-auto">
+        <form method="post" enctype="multipart/form-data">
             {% csrf_token %}
-            {{ form.as_table }}
-            <tr>
-                <td></td>
-                <td>
-                    <input type="submit" value="Submit" />
-                </td>
-            </tr>
-            {{ additional_row }}
-        </table>
-    </form>
+            {{ form.as_div }}
+            <div><input type="submit" value="Submit" /></div>
+            <div class="submit-button-container">
+                {{ additional_row }}
+            </div>
+        </form>
+    </div>
+</div>
 {% endif %}
 <c-slot name="scripts">
 {% if script_name %}

games/templates/cotton/layouts/base.html

@@ -12,6 +12,10 @@
         {% 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>
+        {% comment %} <script src="//unpkg.com/alpinejs" defer></script>
+        <script src="//unpkg.com/@alpinejs/mask" defer></script> {% endcomment %}
+        <script defer src="https://cdn.jsdelivr.net/npm/@alpinejs/mask@3.x.x/dist/cdn.min.js"></script>
+        <script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3.x.x/dist/cdn.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)) {

games/templates/cotton/price_converted.html

@@ -0,0 +1 @@
+<span title="Price is a result of conversion and rounding." class="decoration-dotted underline">{{ slot }}</span>

games/templates/gamestatuschange_confirm_delete.html

@@ -0,0 +1,16 @@
+<c-layouts.base>
+    {% load static %}
+    <div class="2xl:max-w-screen-2xl xl:max-w-screen-xl md:max-w-screen-md sm:max-w-screen-sm self-center">
+        <form method="post" class="dark:text-white">
+            {% csrf_token %}
+            <div>
+                <p>Are you sure you want to delete this status change?</p>
+                <c-button color="red" type="submit" size="lg" class="w-full">Delete</c-button>
+                <a href="{% url 'view_game' object.game.id %}" class="">
+                    <c-button color="gray" class="w-full">Cancel</c-button>
+                </a>
+            </div>
+        </form>
+    </div>
+</c-layouts.base>
+

games/templates/gamestatuschange_list.html

@@ -0,0 +1,7 @@
+<c-layouts.base>
+    {% load static %}
+    <div class="2xl:max-w-screen-2xl xl:max-w-screen-xl md:max-w-screen-md sm:max-w-screen-sm self-center">
+        <c-simple-table :columns=["Test"] :rows=data.rows :page_obj=page_obj :elided_page_range=elided_page_range :header_action=data.header_action />
+    </div>
+    </c-layouts.base>
+    

games/templates/list_playevents.html

@@ -0,0 +1,6 @@
+<c-layouts.base>
+{% load static %}
+<div class="2xl:max-w-screen-2xl xl:max-w-screen-xl md:max-w-screen-md sm:max-w-screen-sm self-center">
+    <c-simple-table :columns=data.columns :rows=data.rows :page_obj=page_obj :elided_page_range=elided_page_range :header_action=data.header_action />
+</div>
+</c-layouts.base>

games/templates/list_sessions.html

@@ -36,8 +36,8 @@
                             <td class="px-2 sm:px-4 md:px-6 md:py-2 purchase-name relative align-top w-24 h-12 group">
                                 <span class="inline-block relative">
                                     <a class="underline decoration-slate-500 sm:decoration-2 inline-block truncate max-w-20char group-hover:absolute group-hover:max-w-none group-hover:-top-8 group-hover:-left-6 group-hover:min-w-60 group-hover:px-6 group-hover:py-3.5 group-hover:bg-purple-600 group-hover:rounded-sm group-hover:outline-dashed group-hover:outline-purple-400 group-hover:outline-4 group-hover:decoration-purple-900 group-hover:text-purple-100"
-                                       href="{% url 'view_game' session.purchase.edition.game.id %}">
-                                        {{ session.purchase.edition.name }}
+                                       href="{% url 'view_game' session.game.id %}">
+                                        {{ session.game.name }}
                                     </a>
                                 </span>
                             </td>

games/templates/navbar.html

@@ -25,7 +25,11 @@
             </svg>
         </button>
         <div class="hidden w-full md:block md:w-auto" id="navbar-dropdown">
-            <ul class="flex flex-col font-medium p-4 md:p-0 mt-4 border border-gray-100 rounded-lg bg-gray-50 md:space-x-8 rtl:space-x-reverse md:flex-row md:mt-0 md:border-0 md:bg-white dark:bg-gray-800 md:dark:bg-gray-900 dark:border-gray-700">
+            <ul class="items-center flex flex-col font-medium p-4 md:p-0 mt-4 border border-gray-100 rounded-lg bg-gray-50 md:space-x-8 rtl:space-x-reverse md:flex-row md:mt-0 md:border-0 md:bg-white dark:bg-gray-800 md:dark:bg-gray-900 dark:border-gray-700">
+                <li class="text-white flex flex-col items-center text-xs">
+                    <span class="flex uppercase gap-1">Today<span class="text-gray-400">·</span>Last 7 days</span>
+                    <span class="flex items-center gap-1">{{ today_played }}<span class="text-gray-400">·</span>{{ last_7_played }}</span>
+                </li>
                 <li>
                     <a href="#"
                        class="block py-2 px-3 text-white bg-blue-700 rounded md:bg-transparent md:text-blue-700 md:p-0 md:dark:text-blue-500 dark:bg-blue-600 md:dark:bg-transparent"
@@ -57,10 +61,6 @@
                                 <a href="{% url 'add_game' %}"
                                    class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Game</a>
                             </li>
-                            <li>
-                                <a href="{% url 'add_edition' %}"
-                                   class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Edition</a>
-                            </li>
                             <li>
                                 <a href="{% url 'add_platform' %}"
                                    class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Platform</a>
@@ -102,14 +102,14 @@
                                 <a href="{% url 'list_games' %}"
                                    class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Games</a>
                             </li>
-                            <li>
-                                <a href="{% url 'list_editions' %}"
-                                   class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Editions</a>
-                            </li>
                             <li>
                                 <a href="{% url 'list_platforms' %}"
                                    class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Platforms</a>
                             </li>
+                            <li>
+                                <a href="{% url 'list_playevents' %}"
+                                   class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Play events</a>
+                            </li>
                             <li>
                                 <a href="{% url 'list_purchases' %}"
                                    class="block px-4 py-2 hover:bg-gray-100 dark:hover:bg-gray-600 dark:hover:text-white">Purchases</a>

games/templates/stats.html

@@ -1,12 +1,17 @@
 <c-layouts.base>
 {% load static %}
+{% load duration_formatter %}
 {% partialdef purchase-name %}
 {% if purchase.type != 'game' %}
-    <c-gamelink :game_id=purchase.first_edition.game.id>
-    {{ purchase.name }} ({{ purchase.first_edition.edition.name }} {{ purchase.get_type_display }})
+    <c-gamelink :game_id=purchase.first_game.id>
+    {% if purchase.game_name %}{{ purchase.game_name }}{% else %}{{ purchase.name }}{% endif %} ({{ purchase.first_game.name }} {{ purchase.get_type_display }})
     </c-gamelink>
 {% else %}
-    <c-gamelink :game_id=purchase.first_edition.game.id :name=purchase.first_edition.name />
+    {% if purchase.game_name %}
+        <c-gamelink :game_id=purchase.first_game.id :name=purchase.game_name />
+    {% else %}
+        <c-gamelink :game_id=purchase.first_game.id :name=purchase.first_game.name />
+    {% endif %}
 {% endif %}
 {% endpartialdef %}
 <div class="dark:text-white max-w-sm sm:max-w-xl lg:max-w-3xl mx-auto">
@@ -46,7 +51,7 @@
             {% endif %}
             <tr>
                 <td class="px-2 sm:px-4 md:px-6 md:py-2">Games ({{ year }})</td>
-                <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ total_2023_games }}</td>
+                <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ total_year_games }}</td>
             </tr>
             {% if all_finished_this_year_count %}
                 <tr>
@@ -107,7 +112,7 @@
                 {% for month in month_playtimes %}
                     <tr>
                         <td class="px-2 sm:px-4 md:px-6 md:py-2">{{ month.month | date:"F" }}</td>
-                        <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ month.playtime }}</td>
+                        <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ month.playtime | format_duration }}</td>
                     </tr>
                 {% endfor %}
             </tbody>
@@ -148,12 +153,12 @@
             </tr>
         </tbody>
     </table>
-    <h1 class="text-5xl text-center my-6">Top games by playtime</h1>
+    <h1 class="text-5xl text-center my-6">Games by playtime</h1>
     <table class="responsive-table">
         <thead>
             <tr>
                 <th class="px-2 sm:px-4 md:px-6 md:py-2">Name</th>
-                <th class="px-2 sm:px-4 md:px-6 md:py-2">Playtime (hours)</th>
+                <th class="px-2 sm:px-4 md:px-6 md:py-2">Playtime</th>
             </tr>
         </thead>
         <tbody>
@@ -162,7 +167,7 @@
                     <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">
                         <c-gamelink :game_id=game.id :name=game.name />
                     </td>
-                    <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ game.formatted_playtime }}</td>
+                    <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ game.playtime | format_duration }}</td>
                 </tr>
             {% endfor %}
         </tbody>
@@ -172,14 +177,14 @@
         <thead>
             <tr>
                 <th class="px-2 sm:px-4 md:px-6 md:py-2">Platform</th>
-                <th class="px-2 sm:px-4 md:px-6 md:py-2">Playtime (hours)</th>
+                <th class="px-2 sm:px-4 md:px-6 md:py-2">Playtime</th>
             </tr>
         </thead>
         <tbody>
             {% for item in total_playtime_per_platform %}
                 <tr>
                     <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ item.platform_name }}</td>
-                    <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ item.formatted_playtime }}</td>
+                    <td class="px-2 sm:px-4 md:px-6 md:py-2 font-mono">{{ item.playtime | format_duration }}</td>
                 </tr>
             {% endfor %}
         </tbody>

games/templates/view_game.html

@@ -16,7 +16,7 @@
                      class="size-6">
                     <path stroke-linecap="round" stroke-linejoin="round" d="M12 6v6h4.5m4.5 0a9 9 0 1 1-18 0 9 9 0 0 1 18 0Z" />
                 </svg>
-                {{ hours_sum }}
+                {{ game.playtime_formatted }}
                 </c-popover>
                 <c-popover id="popover-sessions" popover_content="Number of sessions" class="flex gap-2 items-center">
                 <svg xmlns="http://www.w3.org/2000/svg"
@@ -52,6 +52,68 @@
                 {{ playrange }}
                 </c-popover>
             </div>
+            <div class="flex flex-col mb-6 text-slate-400 gap-y-4">
+                <div class="flex gap-2 items-center">
+                    <span class="uppercase">Original year</span>
+                    <span class="text-slate-300">{{ game.original_year_released }}</span>
+                </div>
+                <div class="flex gap-2 items-center">
+                    <span class="uppercase">Status</span>
+                    <c-gamestatus :status="game.status" class="text-slate-300">
+                        {{ game.get_status_display }}
+                    </c-gamestatus>
+                    {% if game.mastered %}👑{% endif %} 
+                </div>
+                <div class="flex gap-2 items-center"
+                     x-data="{ open: false }"
+                >
+                    <span class="uppercase">Played</span>
+                    <div class="inline-flex rounded-md shadow-xs" role="group" x-data="{ played: {{ game.playevents.count }} }">
+                        <a href="{% url 'add_playevent' %}">
+                        <button type="button" class="px-4 py-2 text-sm font-medium text-gray-900 bg-white border border-gray-200 rounded-s-lg 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">
+                            <span x-text="played"></span> times
+                        </button>
+                        </a>
+                        <button type="button" x-on:click="open = !open" class="relative px-4 py-2 text-sm font-medium text-gray-900 bg-white border-e border-b border-t border-gray-200 rounded-e-lg 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 align-middle">
+                            <svg class="text-white w-3" viewBox="5 8 14 8" fill="none" xmlns="http://www.w3.org/2000/svg">
+                                <path d="M6 9L12 15L18 9" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>
+                                </svg>
+                            <div
+                                class="absolute top-[100%] -left-[1px] w-auto whitespace-nowrap z-10 text-sm font-medium bg-gray-800/20 backdrop-blur-lg rounded-md rounded-tl-none border border-gray-200 dark:border-gray-700"
+                                x-show="open"
+                            >
+                                <ul
+                                    class=""
+                                >
+                                    <li class="px-4 py-2 dark:hover:text-white dark:hover:bg-gray-700 dark:focus:ring-blue-500 dark:focus:text-white rounded-tr-md">
+                                        <a href="{% url 'add_playevent_for_game' game.id %}">Add playthrough...</a>
+                                    </li>
+                                    <li
+                                        x-on:click="createPlayEvent"
+                                        class="relative px-4 py-2 dark:hover:text-white dark:hover:bg-gray-700 dark:focus:ring-blue-500 dark:focus:text-white rounded-b-md"
+                                    >
+                                        Played times +1
+                                    </li>
+                                    <script>
+                                       function createPlayEvent() {
+                                        this.played++;
+                                        fetch('{% url 'api-1.0.0:create_playevent' %}', { method: 'POST', headers: { 'X-CSRFToken': '{{ csrf_token }}' }, body: '{"game_id": {{ game.id }}}'})
+                                       }
+                                    </script>
+                                </ul>
+                            </div>
+                        </button>
+                      </div>
+                </div>
+
+
+  
+  
+                <div class="flex gap-2 items-center">
+                    <span class="uppercase">Platform</span>
+                    <span class="text-slate-300">{{ game.platform }}</span>
+                </div>
+            </div>
             <div class="inline-flex rounded-md shadow-sm mb-3" role="group">
                 <a href="{% url 'edit_game' game.id %}">
                     <button type="button"
@@ -67,17 +129,39 @@
                 </a>
             </div>
         </div>
-        <c-h1 :badge="edition_count">Editions</c-h1>
-        <div class="mb-6">
-            <c-simple-table :rows=edition_data.rows :columns=edition_data.columns />
-        </div>
         <div class="mb-6">
             <c-h1 :badge="purchase_count">Purchases</c-h1>
+            {% if purchase_count %}
             <c-simple-table :rows=purchase_data.rows :columns=purchase_data.columns />
+            {% else %}
+            No purchases yet.
+            {% endif %}
         </div>
         <div class="mb-6">
             <c-h1 :badge="session_count">Sessions</c-h1>
+            {% if session_count %}
             <c-simple-table :rows=session_data.rows :columns=session_data.columns :header_action=session_data.header_action :page_obj=session_page_obj :elided_page_range=session_elided_page_range />
+            {% else %}
+            No sessions yet.
+            {% endif %}
+        </div>
+        <!-- list all playevents -->
+        <div class="mb-6">
+            <c-h1 :badge="playevent_count">Play Events</c-h1>
+            {% if playevent_count %}
+                <c-simple-table :rows=playevent_data.rows :columns=playevent_data.columns />
+            {% else %}
+                No play events yet.
+            {% endif %}
+        </div>
+        <div class="mb-6">
+            <c-h1 :badge="statuschange_count">History</c-h1>
+            <ul class="list-disc list-inside">
+                {% for change in statuschanges %}
+                <li class="text-slate-500">
+                    {% if change.timestamp %}{{ change.timestamp | date:"d/m/Y H:i" }}: Changed{% else %}At some point changed{% endif %} status from <c-gamestatus :status="change.old_status" class="text-white">{{ change.get_old_status_display }}</c-gamestatus> to <c-gamestatus :status="change.new_status" class="text-white">{{ change.get_new_status_display }}</c-gamestatus> (<a href="{% url 'edit_statuschange' change.id %}">Edit</a>, <a href="{% url 'delete_statuschange' change.id %}">Delete</a>)</li>
+                {% endfor %}
+            </ul>
         </div>
     </div>
     <script>

games/templates/view_purchase.html

@@ -2,8 +2,17 @@
     <div class="dark:text-white max-w-sm sm:max-w-xl lg:max-w-3xl mx-auto">
     
     <div class="flex flex-col gap-5 mb-3">
+        <div class="font-bold font-serif text-slate-500 text-2xl">
+        {% if not purchase.name %}
+            Unnamed purchase
+        {% else %}
+            {{ purchase.name }}
+        {% endif %}
+        </div>
     <span class="text-balance max-w-[30rem] text-4xl">
-        <span class="font-bold font-serif">{% if purchase.name %}{{ purchase.name }}{% else %}Unnamed purchase{% endif %}</span> <span class="text-slate-500 text-2xl">({{ purchase.editions.count }} games)</span>
+        <span class="font-bold font-serif">
+            {{ purchase.date_purchased }} ({{ purchase.num_purchases }} game{{ purchase.num_purchases|pluralize}})
+        </span>
     </span>
     <div class="inline-flex rounded-md shadow-sm mb-3" role="group">
         <a href="{% url 'edit_purchase' purchase.id %}">
@@ -19,12 +28,19 @@
             </button>
         </a>
     </div>
-    <div>Price: {{ purchase.converted_price | floatformat }} {{ purchase.converted_currency }} ({{ purchase.price | floatformat }} {{ purchase.price_currency }})</div>
+    <div>
+        <p>
+            Price:
+            <c-price-converted>{{ purchase.standardized_price }}</c-price-converted>
+             ({{ purchase.price | floatformat:2 }} {{ purchase.price_currency }})
+        </p>
+        <p>Price per game: <c-price-converted>{{ purchase.price_per_game | floatformat:0 }} {{ purchase.converted_currency }}</c-price-converted> </p>
+    </div>
     <div>
         <h2 class="text-base">Items:</h2>
         <ul class="list-disc list-inside">
-        {% for edition in purchase.editions.all %}
-        <li><c-gamelink :game_id=edition.game.id :name=edition.name /></li>
+        {% for game in purchase.games.all %}
+        <li><c-gamelink :game_id=game.id :name=game.name /></li>
         {% endfor %}
         </ul>
     </div>

games/templatetags/duration_formatter.py

@@ -0,0 +1,12 @@
+from datetime import timedelta
+
+from django import template
+
+from common.time import durationformat, format_duration
+
+register = template.Library()
+
+
+@register.filter(name="format_duration")
+def filter_format_duration(duration: timedelta, argument: str = durationformat):
+    return format_duration(duration, format_string=argument)

games/urls.py

@@ -1,6 +1,16 @@
 from django.urls import path
 
-from games.views import device, edition, game, general, platform, purchase, session
+from games.api import api
+from games.views import (
+    device,
+    game,
+    general,
+    platform,
+    playevent,
+    purchase,
+    session,
+    statuschange,
+)
 
 urlpatterns = [
     path("", general.index, name="index"),
@@ -8,19 +18,6 @@ urlpatterns = [
     path("device/delete/<int:device_id>", device.delete_device, name="delete_device"),
     path("device/edit/<int:device_id>", device.edit_device, name="edit_device"),
     path("device/list", device.list_devices, name="list_devices"),
-    path("edition/add", edition.add_edition, name="add_edition"),
-    path(
-        "edition/add/for-game/<int:game_id>",
-        edition.add_edition,
-        name="add_edition_for_game",
-    ),
-    path("edition/<int:edition_id>/edit", edition.edit_edition, name="edit_edition"),
-    path("edition/list", edition.list_editions, name="list_editions"),
-    path(
-        "edition/<int:edition_id>/delete",
-        edition.delete_edition,
-        name="delete_edition",
-    ),
     path("game/add", game.add_game, name="add_game"),
     path("game/<int:game_id>/edit", game.edit_game, name="edit_game"),
     path("game/<int:game_id>/view", game.view_game, name="view_game"),
@@ -38,7 +35,29 @@ urlpatterns = [
         name="delete_platform",
     ),
     path("platform/list", platform.list_platforms, name="list_platforms"),
+    path("playevent/list", playevent.list_playevents, name="list_playevents"),
+    path("playevent/add", playevent.add_playevent, name="add_playevent"),
+    path(
+        "playevent/add/for-game/<int:game_id>",
+        playevent.add_playevent,
+        name="add_playevent_for_game",
+    ),
+    path(
+        "playevent/edit/<int:playevent_id>",
+        playevent.edit_playevent,
+        name="edit_playevent",
+    ),
+    path(
+        "playevent/delete/<int:playevent_id>",
+        playevent.delete_playevent,
+        name="delete_playevent",
+    ),
     path("purchase/add", purchase.add_purchase, name="add_purchase"),
+    path(
+        "purchase/add/for-game/<int:game_id>",
+        purchase.add_purchase,
+        name="add_purchase_for_game",
+    ),
     path(
         "purchase/<int:purchase_id>/edit",
         purchase.edit_purchase,
@@ -75,20 +94,15 @@ urlpatterns = [
         name="refund_purchase",
     ),
     path(
-        "purchase/related-purchase-by-edition",
-        purchase.related_purchase_by_edition,
-        name="related_purchase_by_edition",
-    ),
-    path(
-        "purchase/add/for-edition/<int:edition_id>",
-        purchase.add_purchase,
-        name="add_purchase_for_edition",
+        "purchase/related-purchase-by-game",
+        purchase.related_purchase_by_game,
+        name="related_purchase_by_game",
     ),
     path("session/add", session.add_session, name="add_session"),
     path(
-        "session/add/for-purchase/<int:purchase_id>",
+        "session/add/for-game/<int:game_id>",
         session.add_session,
-        name="add_session_for_purchase",
+        name="add_session_for_game",
     ),
     path(
         "session/add/from-game/<int:session_id>",
@@ -122,10 +136,31 @@ urlpatterns = [
     ),
     path("session/list", session.list_sessions, name="list_sessions"),
     path("session/search", session.search_sessions, name="search_sessions"),
+    path(
+        "statuschange/add",
+        statuschange.AddStatusChangeView.as_view(),
+        name="add_statuschange",
+    ),
+    path(
+        "statuschange/edit/<int:statuschange_id>",
+        statuschange.EditStatusChangeView.as_view(),
+        name="edit_statuschange",
+    ),
+    path(
+        "statuschange/delete/<int:pk>",
+        statuschange.GameStatusChangeDeleteView.as_view(),
+        name="delete_statuschange",
+    ),
+    path(
+        "statuschange/list",
+        statuschange.GameStatusChangeListView.as_view(),
+        name="list_statuschanges",
+    ),
     path("stats/", general.stats_alltime, name="stats_alltime"),
     path(
         "stats/<int:year>",
         general.stats,
         name="stats_by_year",
     ),
+    path("api/", api.urls),
 ]