timetracker/games/models.py

253 lines
8.1 KiB
Python
Raw Normal View History

from datetime import timedelta
2023-11-15 18:36:22 +00:00
from django.core.exceptions import ValidationError
2023-11-15 18:36:22 +00:00
from django.db import models
from django.core.exceptions import ValidationError
2023-01-15 22:39:52 +00:00
from django.db.models import F, Manager, Sum
2023-11-15 18:36:22 +00:00
from django.utils import timezone
from common.time import format_duration
2022-12-31 13:18:27 +00:00
class Game(models.Model):
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)
wikidata = models.CharField(max_length=50, null=True, blank=True, default=None)
created_at = models.DateTimeField(auto_now_add=True)
2022-12-31 13:18:27 +00:00
def __str__(self):
return self.name
def save(self, *args, **kwargs):
def get_sort_name(name):
articles = ["a", "an", "the"]
name_parts = name.split()
first_word = name_parts[0].lower()
if first_word in articles:
2023-11-09 14:41:46 +00:00
return f"{' '.join(name_parts[1:])}, {name_parts[0]}"
else:
2023-11-09 14:41:46 +00:00
return name
self.sort_name = get_sort_name(self.name)
2023-11-09 14:41:46 +00:00
super().save(*args, **kwargs)
2022-12-31 13:18:27 +00:00
2023-02-18 19:49:46 +00:00
class Edition(models.Model):
class Meta:
unique_together = [["name", "platform"]]
2022-12-31 13:18:27 +00:00
game = models.ForeignKey("Game", on_delete=models.CASCADE)
2023-02-18 19:49:46 +00:00
name = models.CharField(max_length=255)
2023-02-20 16:13:21 +00:00
platform = models.ForeignKey("Platform", on_delete=models.CASCADE)
year_released = models.IntegerField(default=datetime.today().year)
2023-02-20 16:13:21 +00:00
wikidata = models.CharField(max_length=50, null=True, blank=True, default=None)
2023-02-18 19:49:46 +00:00
def __str__(self):
return self.sort_name
def save(self, *args, **kwargs):
def get_sort_name(name):
articles = ["a", "an", "the"]
name_parts = name.split()
first_word = name_parts[0].lower()
if first_word in articles:
2023-11-09 14:41:46 +00:00
return f"{' '.join(name_parts[1:])}, {name_parts[0]}"
else:
2023-11-09 14:41:46 +00:00
return name
self.sort_name = get_sort_name(self.name)
2023-11-09 14:41:46 +00:00
super().save(*args, **kwargs)
2023-02-18 19:49:46 +00:00
class PurchaseQueryset(models.QuerySet):
def refunded(self):
return self.filter(date_refunded__isnull=False)
def not_refunded(self):
return self.filter(date_refunded__isnull=True)
def finished(self):
return self.filter(date_finished__isnull=False)
2023-11-14 18:27:00 +00:00
def games_only(self):
return self.filter(type=Purchase.GAME)
2023-02-18 19:49:46 +00:00
class Purchase(models.Model):
PHYSICAL = "ph"
DIGITAL = "di"
DIGITALUPGRADE = "du"
RENTED = "re"
BORROWED = "bo"
TRIAL = "tr"
DEMO = "de"
PIRATED = "pi"
OWNERSHIP_TYPES = [
(PHYSICAL, "Physical"),
(DIGITAL, "Digital"),
(DIGITALUPGRADE, "Digital Upgrade"),
(RENTED, "Rented"),
(BORROWED, "Borrowed"),
(TRIAL, "Trial"),
(DEMO, "Demo"),
(PIRATED, "Pirated"),
]
2023-11-14 18:27:00 +00:00
GAME = "game"
DLC = "dlc"
SEASONPASS = "season_pass"
BATTLEPASS = "battle_pass"
TYPES = [
(GAME, "Game"),
(DLC, "DLC"),
(SEASONPASS, "Season Pass"),
(BATTLEPASS, "Battle Pass"),
]
objects = PurchaseQueryset().as_manager()
2023-02-18 19:49:46 +00:00
edition = models.ForeignKey("Edition", on_delete=models.CASCADE)
platform = models.ForeignKey(
"Platform", on_delete=models.CASCADE, default=None, null=True, blank=True
)
2022-12-31 13:18:27 +00:00
date_purchased = models.DateField()
date_refunded = models.DateField(blank=True, null=True)
date_finished = models.DateField(blank=True, null=True)
2023-02-18 19:53:47 +00:00
price = models.IntegerField(default=0)
price_currency = models.CharField(max_length=3, default="USD")
ownership_type = models.CharField(
max_length=2, choices=OWNERSHIP_TYPES, default=DIGITAL
)
2023-11-14 18:27:00 +00:00
type = models.CharField(max_length=255, choices=TYPES, default=GAME)
name = models.CharField(max_length=255, default="", null=True, blank=True)
2023-11-14 18:27:00 +00:00
related_purchase = models.ForeignKey(
2023-11-14 18:27:00 +00:00
"Purchase", on_delete=models.SET_NULL, default=None, null=True, blank=True
2023-11-14 18:27:00 +00:00
)
2022-12-31 13:18:27 +00:00
def __str__(self):
2023-02-20 16:13:21 +00:00
platform_info = self.platform
if self.platform != self.edition.platform:
platform_info = f"{self.edition.platform} version on {self.platform}"
return f"{self.edition} ({platform_info}, {self.edition.year_released}, {self.get_ownership_type_display()})"
2023-11-14 18:27:00 +00:00
2023-11-14 18:27:00 +00:00
def is_game(self):
return self.type == self.GAME
def save(self, *args, **kwargs):
if self.type == Purchase.GAME:
self.name = ""
elif self.type != Purchase.GAME and not self.related_purchase:
raise ValidationError(
f"{self.get_type_display()} must have a related purchase."
)
2023-11-14 18:27:00 +00:00
super().save(*args, **kwargs)
2022-12-31 13:18:27 +00:00
class Platform(models.Model):
name = models.CharField(max_length=255)
group = models.CharField(max_length=255, null=True, blank=True, default=None)
created_at = models.DateTimeField(auto_now_add=True)
2022-12-31 13:18:27 +00:00
def __str__(self):
return self.name
class SessionQuerySet(models.QuerySet):
def total_duration_formatted(self):
return format_duration(self.total_duration_unformatted())
def total_duration_unformatted(self):
result = self.aggregate(
duration=Sum(F("duration_calculated") + F("duration_manual"))
)
return result["duration"]
2022-12-31 13:18:27 +00:00
class Session(models.Model):
class Meta:
get_latest_by = "timestamp_start"
2022-12-31 13:18:27 +00:00
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)
device = models.ForeignKey(
"Device",
on_delete=models.CASCADE,
null=True,
blank=True,
default=None,
)
note = models.TextField(blank=True, null=True)
created_at = models.DateTimeField(auto_now_add=True)
modified_at = models.DateTimeField(auto_now=True)
2022-12-31 13:18:27 +00:00
objects = SessionQuerySet.as_manager()
2022-12-31 13:18:27 +00:00
def __str__(self):
2023-11-11 14:02:28 +00:00
mark = ", manual" if self.is_manual() else ""
return f"{str(self.purchase)} {str(self.timestamp_start.date())} ({self.duration_formatted()}{mark})"
2022-12-31 13:18:27 +00:00
def finish_now(self):
self.timestamp_end = timezone.now()
def start_now():
self.timestamp_start = timezone.now()
def duration_seconds(self) -> timedelta:
manual = timedelta(0)
calculated = timedelta(0)
2023-11-11 14:02:28 +00:00
if self.is_manual():
manual = self.duration_manual
if self.timestamp_end != None and self.timestamp_start != None:
calculated = self.timestamp_end - self.timestamp_start
return timedelta(seconds=(manual + calculated).total_seconds())
2023-01-02 18:36:22 +00:00
def duration_formatted(self) -> str:
result = format_duration(self.duration_seconds(), "%02.0H:%02.0m")
return result
2023-01-04 16:27:54 +00:00
2023-11-11 14:02:28 +00:00
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()
2023-01-04 16:25:19 +00:00
def save(self, *args, **kwargs):
if self.timestamp_start != None and self.timestamp_end != None:
self.duration_calculated = self.timestamp_end - self.timestamp_start
else:
self.duration_calculated = timedelta(0)
if not self.device:
default_device, _ = Device.objects.get_or_create(
type=Device.UNKNOWN, defaults={"name": "Unknown"}
)
self.device = default_device
2023-01-04 16:25:19 +00:00
super(Session, self).save(*args, **kwargs)
2023-02-18 20:12:18 +00:00
class Device(models.Model):
PC = "pc"
CONSOLE = "co"
HANDHELD = "ha"
MOBILE = "mo"
SBC = "sbc"
UNKNOWN = "un"
2023-02-18 20:12:18 +00:00
DEVICE_TYPES = [
(PC, "PC"),
(CONSOLE, "Console"),
(HANDHELD, "Handheld"),
(MOBILE, "Mobile"),
(SBC, "Single-board computer"),
(UNKNOWN, "Unknown"),
2023-02-18 20:12:18 +00:00
]
name = models.CharField(max_length=255)
type = models.CharField(max_length=3, choices=DEVICE_TYPES, default=UNKNOWN)
created_at = models.DateTimeField(auto_now_add=True)
2023-02-18 20:12:18 +00:00
def __str__(self):
return f"{self.name} ({self.get_type_display()})"