242 lines
8.9 KiB
Python
242 lines
8.9 KiB
Python
from __future__ import annotations
|
|
|
|
import logging
|
|
from typing import TYPE_CHECKING, ClassVar
|
|
|
|
from django.db import models
|
|
from django.utils import timezone
|
|
|
|
from accounts.models import User
|
|
|
|
if TYPE_CHECKING:
|
|
import datetime
|
|
|
|
logger: logging.Logger = logging.getLogger("ttvdrops")
|
|
|
|
|
|
class Game(models.Model):
|
|
"""Represents a game on Twitch."""
|
|
|
|
id = models.TextField(primary_key=True)
|
|
slug = models.TextField(blank=True, default="", db_index=True)
|
|
name = models.TextField(blank=True, default="", db_index=True)
|
|
display_name = models.TextField(blank=True, default="", db_index=True)
|
|
box_art = models.URLField(max_length=500, blank=True, default="")
|
|
|
|
class Meta:
|
|
indexes: ClassVar[list] = [
|
|
models.Index(fields=["slug"]),
|
|
models.Index(fields=["display_name"]),
|
|
models.Index(fields=["name"]),
|
|
models.Index(fields=["box_art"]),
|
|
]
|
|
|
|
def __str__(self) -> str:
|
|
"""Return a string representation of the game."""
|
|
if (self.display_name and self.name) and (self.display_name != self.name):
|
|
logger.warning(
|
|
"Game display name '%s' does not match name '%s'.",
|
|
self.display_name,
|
|
self.name,
|
|
)
|
|
return f"{self.display_name} ({self.name})"
|
|
return self.name or self.slug or self.id
|
|
|
|
@property
|
|
def organizations(self) -> models.QuerySet[Organization]:
|
|
"""Return all organizations that have drop campaigns for this game."""
|
|
return Organization.objects.filter(drop_campaigns__game=self).distinct()
|
|
|
|
|
|
class Organization(models.Model):
|
|
"""Represents an organization on Twitch that can own drop campaigns."""
|
|
|
|
id = models.TextField(primary_key=True)
|
|
name = models.TextField(db_index=True)
|
|
|
|
class Meta:
|
|
indexes: ClassVar[list] = [
|
|
models.Index(fields=["name"]),
|
|
]
|
|
|
|
def __str__(self) -> str:
|
|
"""Return a string representation of the organization."""
|
|
return self.name
|
|
|
|
|
|
class DropCampaign(models.Model):
|
|
"""Represents a Twitch drop campaign."""
|
|
|
|
id = models.TextField(primary_key=True)
|
|
name = models.TextField(db_index=True)
|
|
description = models.TextField(blank=True)
|
|
details_url = models.URLField(max_length=500, blank=True, default="")
|
|
account_link_url = models.URLField(max_length=500, blank=True, default="")
|
|
image_url = models.URLField(max_length=500, blank=True, default="")
|
|
start_at = models.DateTimeField(db_index=True, null=True)
|
|
end_at = models.DateTimeField(db_index=True, null=True)
|
|
is_account_connected = models.BooleanField(default=False)
|
|
|
|
# Foreign keys
|
|
game = models.ForeignKey(Game, on_delete=models.CASCADE, related_name="drop_campaigns", db_index=True)
|
|
owner = models.ForeignKey(Organization, on_delete=models.CASCADE, related_name="drop_campaigns", db_index=True)
|
|
|
|
# Tracking fields
|
|
created_at = models.DateTimeField(auto_now_add=True)
|
|
updated_at = models.DateTimeField(auto_now=True)
|
|
|
|
class Meta:
|
|
indexes: ClassVar[list] = [
|
|
models.Index(fields=["name"]),
|
|
models.Index(fields=["start_at", "end_at"]),
|
|
models.Index(fields=["game"]),
|
|
models.Index(fields=["owner"]),
|
|
]
|
|
|
|
def __str__(self) -> str:
|
|
"""Return a string representation of the drop campaign."""
|
|
return self.name
|
|
|
|
@property
|
|
def is_active(self) -> bool:
|
|
"""Check if the campaign is currently active."""
|
|
now: datetime.datetime = timezone.now()
|
|
if self.start_at is None or self.end_at is None:
|
|
return False
|
|
return self.start_at <= now <= self.end_at
|
|
|
|
@property
|
|
def clean_name(self) -> str:
|
|
"""Return the campaign name without the game name prefix.
|
|
|
|
Examples:
|
|
"Ravendawn - July 2" -> "July 2"
|
|
"Party Animals Twitch Drop" -> "Twitch Drop"
|
|
"Skull & Bones - Closed Beta" -> "Closed Beta" (& is replaced with "and")
|
|
"""
|
|
if not self.game or not self.game.display_name:
|
|
return self.name
|
|
|
|
# Try different variations of the game name
|
|
game_variations = [self.game.display_name]
|
|
|
|
# Add & to "and" conversion
|
|
if "&" in self.game.display_name:
|
|
game_variations.append(self.game.display_name.replace("&", "and"))
|
|
|
|
# Add "and" to & conversion
|
|
if "and" in self.game.display_name:
|
|
game_variations.append(self.game.display_name.replace("and", "&"))
|
|
|
|
# Check each variation
|
|
for game_name in game_variations:
|
|
if not self.name.startswith(game_name):
|
|
continue
|
|
|
|
# Check if it's followed by a separator like " - "
|
|
if self.name[len(game_name) :].startswith(" - "):
|
|
return self.name[len(game_name) + 3 :].strip()
|
|
|
|
# Or just remove the game name if it's followed by a space
|
|
if len(self.name) > len(game_name) and self.name[len(game_name)] == " ":
|
|
return self.name[len(game_name) + 1 :].strip()
|
|
|
|
return self.name
|
|
|
|
|
|
class DropBenefit(models.Model):
|
|
"""Represents a benefit that can be earned from a drop."""
|
|
|
|
id = models.TextField(primary_key=True)
|
|
name = models.TextField(db_index=True, blank=True, default="N/A")
|
|
image_asset_url = models.URLField(max_length=500, blank=True, default="")
|
|
created_at = models.DateTimeField(db_index=True, null=True)
|
|
entitlement_limit = models.PositiveIntegerField(default=1)
|
|
is_ios_available = models.BooleanField(default=False)
|
|
distribution_type = models.TextField(db_index=True, blank=True, default="")
|
|
|
|
# Foreign keys
|
|
game = models.ForeignKey(Game, on_delete=models.CASCADE, related_name="drop_benefits", db_index=True)
|
|
owner_organization = models.ForeignKey(Organization, on_delete=models.CASCADE, related_name="drop_benefits", db_index=True)
|
|
|
|
class Meta:
|
|
indexes: ClassVar[list] = [
|
|
models.Index(fields=["name"]),
|
|
models.Index(fields=["created_at"]),
|
|
models.Index(fields=["distribution_type"]),
|
|
models.Index(fields=["game"]),
|
|
models.Index(fields=["owner_organization"]),
|
|
]
|
|
|
|
def __str__(self) -> str:
|
|
"""Return a string representation of the drop benefit."""
|
|
return self.name
|
|
|
|
|
|
class TimeBasedDrop(models.Model):
|
|
"""Represents a time-based drop in a drop campaign."""
|
|
|
|
id = models.TextField(primary_key=True)
|
|
name = models.TextField(db_index=True)
|
|
required_minutes_watched = models.PositiveIntegerField(db_index=True, null=True)
|
|
required_subs = models.PositiveIntegerField(default=0)
|
|
start_at = models.DateTimeField(db_index=True, null=True)
|
|
end_at = models.DateTimeField(db_index=True, null=True)
|
|
|
|
# Foreign keys
|
|
campaign = models.ForeignKey(DropCampaign, on_delete=models.CASCADE, related_name="time_based_drops", db_index=True)
|
|
benefits = models.ManyToManyField(DropBenefit, through="DropBenefitEdge", related_name="drops") # type: ignore[var-annotated]
|
|
|
|
class Meta:
|
|
indexes: ClassVar[list] = [
|
|
models.Index(fields=["name"]),
|
|
models.Index(fields=["start_at", "end_at"]),
|
|
models.Index(fields=["campaign"]),
|
|
models.Index(fields=["required_minutes_watched"]),
|
|
]
|
|
|
|
def __str__(self) -> str:
|
|
"""Return a string representation of the time-based drop."""
|
|
return self.name
|
|
|
|
|
|
class DropBenefitEdge(models.Model):
|
|
"""Represents the relationship between a TimeBasedDrop and a DropBenefit."""
|
|
|
|
drop = models.ForeignKey(TimeBasedDrop, on_delete=models.CASCADE, db_index=True)
|
|
benefit = models.ForeignKey(DropBenefit, on_delete=models.CASCADE, db_index=True)
|
|
entitlement_limit = models.PositiveIntegerField(default=1)
|
|
|
|
class Meta:
|
|
unique_together = ("drop", "benefit")
|
|
indexes: ClassVar[list] = [
|
|
models.Index(fields=["drop", "benefit"]),
|
|
]
|
|
|
|
def __str__(self) -> str:
|
|
"""Return a string representation of the drop benefit edge."""
|
|
return f"{self.drop.name} - {self.benefit.name}"
|
|
|
|
|
|
class NotificationSubscription(models.Model):
|
|
"""Users can subscribe to games to get notified."""
|
|
|
|
user = models.ForeignKey(User, on_delete=models.CASCADE)
|
|
game = models.ForeignKey(Game, null=True, blank=True, on_delete=models.CASCADE)
|
|
organization = models.ForeignKey(Organization, null=True, blank=True, on_delete=models.CASCADE)
|
|
|
|
notify_found = models.BooleanField(default=False)
|
|
notify_live = models.BooleanField(default=False)
|
|
|
|
class Meta:
|
|
unique_together: ClassVar[list[tuple[str, str]]] = [
|
|
("user", "game"),
|
|
("user", "organization"),
|
|
]
|
|
|
|
def __str__(self) -> str:
|
|
if self.game:
|
|
return f"{self.user} subscription to game: {self.game.display_name}"
|
|
if self.organization:
|
|
return f"{self.user} subscription to organization: {self.organization.name}"
|
|
return f"{self.user} subscription"
|