class SeasonWinner(ModelMixin, db.Model): """ Model that describes the 'season_winners' SQL table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "season_winners" league: str = db.Column(db.String(255), primary_key=True) season: int = db.Column(db.Integer, primary_key=True) user_id: int = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False) user: User = db.relationship("User", backref=db.backref("season_winners", cascade="all, delete")) @property def season_string(self) -> str: """ :return: The season string, e.g. Bundesliga 2019/20 """ return Config.league_string(self.league, self.season)
class UserProfile(ModelMixin, db.Model): """ Model that describes the 'user_profiles' SQL table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "user_profiles" user_id: int = db.Column(db.Integer, db.ForeignKey("users.id", ondelete="CASCADE"), primary_key=True) favourite_team_abbreviation: Optional[str] = db.Column( db.String(3), db.ForeignKey("teams.abbreviation"), nullable=True) description: Optional[str] = db.Column(db.String(255), nullable=True) country: Optional[str] = db.Column(db.String(255), nullable=True) user: User = db.relationship( "User", backref=db.backref("profile", cascade="all, delete", uselist=False), ) favourite_team: Team = db.relationship("Team")
class B(IDModelMixin, db.Model): __tablename__ = "b" a_id = db.Column(db.Integer, db.ForeignKey("a.id")) a = db.relationship("A") user_id: int = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
class ApiKey(IDModelMixin, db.Model): """ Model that describes the 'api_keys' SQL table An ApiKey is used for API access using HTTP basic auth """ __tablename__ = "api_keys" """ The name of the table """ user_id: int = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False) """ The ID of the user associated with this API key """ user: User = db.relationship("User", back_populates="api_keys") """ The user associated with this API key """ key_hash: str = db.Column(db.String(255), nullable=False) """ The hash of the API key """ creation_time: int = \ db.Column(db.Integer, nullable=False, default=time.time) """ The time at which this API key was created as a UNIX timestamp """ def has_expired(self) -> bool: """ Checks if the API key has expired. API Keys expire after 30 days :return: True if the key has expired, False otherwise """ return time.time() - self.creation_time > Config.MAX_API_KEY_AGE def verify_key(self, key: str) -> bool: """ Checks if a given key is valid :param key: The key to check :return: True if the key is valid, False otherwise """ try: _id, api_key = key.split(":", 1) if int(_id) != self.id: return False else: return verify_password(api_key, self.key_hash) except ValueError: return False
class MediaNotification(ModelMixin, db.Model): """ Database model that stores a media notification for a user """ __tablename__ = "media_notifications" """ The name of the database table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) media_user_state_id: int = db.Column(db.Integer, db.ForeignKey("media_user_states.id"), nullable=False, unique=True) """ The ID of the media user state this notification references """ media_user_state: MediaUserState = db.relationship( "MediaUserState", back_populates="media_notification") """ The media user state this notification references """ last_update = db.Column(db.Integer, nullable=False) """ The last update value sent to the user """ @property def identifier_tuple(self) -> Tuple[int]: """ :return: A tuple that uniquely identifies this database entry """ return self.media_user_state_id, def update(self, new_data: "MediaNotification"): """ Updates the data in this record based on another object :param new_data: The object from which to use the new values :return: None """ self.media_user_state_id = new_data.media_user_state_id self.last_update = new_data.last_update
class SeasonEvent(ModelMixin, db.Model): """ Model that describes the 'season_events' SQL table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "season_events" season: int = db.Column(db.Integer, primary_key=True) league: int = db.Column(db.String(255), primary_key=True) event_type: SeasonEventType = db.Column(db.Enum(SeasonEventType), primary_key=True) executed: bool = db.Column(db.Boolean, nullable=False, default=False)
class DisplayBotsSettings(ModelMixin, db.Model): """ Database model that specifies whether a user wants to see bots or not """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "display_bot_settings" user_id: int = db.Column(db.Integer, db.ForeignKey("users.id"), primary_key=True) display_bots = db.Column(db.Boolean, nullable=False, default=True) user: User = db.relationship("User", backref=db.backref("display_bot_settings", cascade="all, delete")) @classmethod def get_state(cls, user: User): """ Retrieves the state of the settings for a give user :param user: The user for which to retrieve the seetings :return: True if active, False otherwise """ bot_setting = DisplayBotsSettings.query.filter_by( user_id=user.id).first() return bot_setting is not None and bot_setting.display_bots @staticmethod def bot_symbol() -> str: """ :return: "The bot unicode symbol" """ return "🤖"
class TelegramChatId(IDModelMixin, db.Model): """ Model that describes the 'telegram_chat_ids' SQL table Maps telegram chat ids to users """ __tablename__ = "telegram_chat_ids" """ The name of the table """ user_id: int = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False) """ The ID of the user associated with this telegram chat ID """ user: User = db.relationship("User", back_populates="telegram_chat_id") """ The user associated with this telegram chat ID """ chat_id: str = db.Column(db.String(255), nullable=False) """ The telegram chat ID """ def send_message(self, message_text: str): """ Sends a message to the telegram chat :param message_text: The message text to send :return: None """ try: address = Address(self.chat_id) message = TextMessage(Config.TELEGRAM_BOT_CONNECTION.address, address, message_text) Config.TELEGRAM_BOT_CONNECTION.send(message) except AttributeError: app.logger.error("Failed to send telegram message: no connection")
class MatchdayWinner(ModelMixin, db.Model): """ Model that describes the 'matchday_winners' SQL table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "matchday_winners" league: str = db.Column(db.String(255), primary_key=True) season: int = db.Column(db.Integer, primary_key=True) matchday: int = db.Column(db.Integer, primary_key=True) user_id: int = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True) user: User = db.relationship("User", backref=db.backref("matchday_winners", cascade="all, delete"))
class IDModelMixin(ModelMixin): """ A mixin class that specifies a couple of methods all database models should implement. Includes an automatically incrementing ID. """ id = db.Column( db.Integer, primary_key=True, nullable=False, autoincrement=True ) """ The ID is the primary key of the table and increments automatically """ def __hash__(self) -> int: """ Creates a hash so that the model objects can be used as keys :return: None """ return hash(self.id)
class Goal(ModelMixin, db.Model): """ Model that describes the "goals" SQL table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "goals" __table_args__ = (db.ForeignKeyConstraint( ("home_team_abbreviation", "away_team_abbreviation", "league", "season", "matchday"), (Match.home_team_abbreviation, Match.away_team_abbreviation, Match.league, Match.season, Match.matchday)), db.ForeignKeyConstraint( ("player_name", "player_team_abbreviation"), (Player.name, Player.team_abbreviation))) league: str = db.Column(db.String(255), primary_key=True) season: int = db.Column(db.Integer, primary_key=True) matchday: int = db.Column(db.Integer, primary_key=True) home_team_abbreviation: str = db.Column(db.String(3), primary_key=True) away_team_abbreviation: str = db.Column(db.String(3), primary_key=True) home_score: int = db.Column(db.Integer, primary_key=True) away_score: int = db.Column(db.Integer, primary_key=True) player_name: str = db.Column(db.String(255), nullable=False) player_team_abbreviation: str = db.Column(db.String(3), nullable=False) minute: int = db.Column(db.Integer, nullable=False) minute_et: int = db.Column(db.Integer, nullable=True, default=0) own_goal: bool = db.Column(db.Boolean, nullable=False, default=False) penalty: bool = db.Column(db.Boolean, nullable=False, default=False) match: Match = db.relationship("Match", overlaps="goals") player: Player = db.relationship("Player", overlaps="goals")
class LnRelease(ModelMixin, db.Model): """ Database model that keeps track of light novel releases """ __tablename__ = "ln_releases" """ The name of the database table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) media_item_id: int = db.Column(db.Integer, db.ForeignKey("media_items.id"), nullable=True) """ The ID of the media item referenced by this release """ media_item: MediaItem = db.relationship("MediaItem", back_populates="ln_releases") """ The media item referenced by this release """ release_date_string: str = db.Column(db.String(10), nullable=False) """ The release date as a ISO-8601 string """ series_name: str = db.Column(db.String(255), nullable=False) """ The series name """ volume: str = db.Column(db.String(255), nullable=False) """ The volume identifier """ publisher: Optional[str] = db.Column(db.String(255), nullable=True) """ The publisher """ purchase_link: Optional[str] = db.Column(db.String(255), nullable=True) """ Link to a store page """ digital: bool = db.Column(db.Boolean) """ Whether this is a digital release """ physical: bool = db.Column(db.Boolean) """ Whether this is a physical release """ @property def release_date(self) -> datetime: """ :return: The release date as a datetime object """ return datetime.strptime(self.release_date_string, "%Y-%m-%d") @property def volume_number(self) -> int: """ :return: The volume number as an integer """ try: if re.match(r"^p[0-9]+[ ]*v[0-9]+$", self.volume.lower()): return int(self.volume.lower().split("v")[1]) else: stripped = "" for char in self.volume: if char.isdigit() or char in [".", "-"]: stripped += char if "-" in stripped: stripped = stripped.split("-")[1] if "." in stripped: stripped = stripped.split(".")[0] return int(stripped) except (TypeError, ValueError): return 0 @property def identifier_tuple(self) -> Tuple[str, str, bool, bool]: """ :return: A tuple that uniquely identifies this database entry """ return self.series_name, self.volume, self.digital, self.physical def update(self, new_data: "LnRelease"): """ Updates the data in this record based on another object :param new_data: The object from which to use the new values :return: None """ self.media_item_id = new_data.media_item_id self.series_name = new_data.series_name self.volume = new_data.volume self.release_date_string = new_data.release_date_string self.purchase_link = new_data.purchase_link self.publisher = new_data.publisher self.physical = new_data.physical self.digital = new_data.digital def get_ids(self) -> List[MediaId]: """ :return: Any related Media IDs """ if self.media_item is None: return [] else: return MediaId.query.filter_by(media_item=self.media_item).all()
class MediaList(ModelMixin, db.Model): """ Database model for user-specific media lists. """ __tablename__ = "media_lists" """ The name of the database table """ __table_args__ = ( db.UniqueConstraint( "name", "user_id", "service", "media_type", name="unique_media_list" ), ) """ Makes sure that objects that should be unique are unique """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) user_id: int = db.Column( db.Integer, db.ForeignKey( "users.id", ondelete="CASCADE", onupdate="CASCADE" ), nullable=False ) """ The ID of the user associated with this list """ user: User = db.relationship( "User", backref=db.backref("media_lists", lazy=True, cascade="all,delete") ) """ The user associated with this list """ name: str = db.Column(db.Unicode(255), nullable=False) """ The name of this list """ service: ListService = db.Column(db.Enum(ListService), nullable=False) """ The service for which this list applies to """ media_type: MediaType = db.Column(db.Enum(MediaType), nullable=False) """ The media type for this list """ media_list_items: List["MediaListItem"] = db.relationship( "MediaListItem", back_populates="media_list", cascade="all, delete" ) """ Media List Items that are a part of this media list """ @property def identifier_tuple(self) -> Tuple[str, int, ListService, MediaType]: """ :return: A tuple that uniquely identifies this database entry """ return self.name, self.user_id, self.service, self.media_type def update(self, new_data: "MediaList"): """ Updates the data in this record based on another object :param new_data: The object from which to use the new values :return: None """ self.user_id = new_data.user_id self.name = new_data.name self.service = new_data.service self.media_type = new_data.media_type
class NotificationSetting(ModelMixin, db.Model): """ Database model that stores notification settings for a user """ __tablename__ = "notification_settings" """ The name of the database table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) user_id: int = db.Column(db.Integer, db.ForeignKey("users.id", ondelete="CASCADE", onupdate="CASCADE"), nullable=False) """ The ID of the user associated with this notification setting """ user: User = db.relationship("User", backref=db.backref("notification_settings", lazy=True, cascade="all,delete")) """ The user associated with this notification setting """ notification_type: str = \ db.Column(db.Enum(NotificationType), nullable=False) """ The notification type """ minimum_score: int = db.Column(db.Integer, default=0, nullable=False) """ The minimum score for notification items """ value: bool = db.Column(db.Boolean, nullable=False, default=False) """ Whether or not the notification is active or not """ @property def identifier_tuple(self) -> Tuple[int]: """ :return: A tuple that uniquely identifies this database entry """ return self.user_id, def update(self, new_data: "NotificationSetting"): """ Updates the data in this record based on another object :param new_data: The object from which to use the new values :return: None """ self.user_id = new_data.user_id self.notification_type = new_data.notification_type self.value = new_data.value self.minimum_score = new_data.minimum_score
class MediaId(ModelMixin, db.Model): """ Database model for media IDs. These are used to map media items to their corresponding external IDS on external sites. """ __tablename__ = "media_ids" """ The name of the database table """ __table_args__ = ( db.UniqueConstraint("media_item_id", "service", "media_type", name="unique_media_item_service_id"), db.UniqueConstraint("media_type", "service", "service_id", name="unique_service_id"), db.ForeignKeyConstraint( ["media_item_id", "media_type", "media_subtype"], [ "media_items.id", "media_items.media_type", "media_items.media_subtype" ]), ) """ Makes sure that objects that should be unique are unique """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) media_item_id: int = db.Column(db.Integer, nullable=False) """ The ID of the media item referenced by this ID """ media_item: MediaItem = db.relationship("MediaItem", back_populates="media_ids") """ The media item referenced by this ID """ media_type: MediaType = db.Column(db.Enum(MediaType), nullable=False) """ The media type of the list item """ media_subtype: MediaSubType = \ db.Column(db.Enum(MediaSubType), nullable=False) """ The media subtype of the list item """ service_id: str = db.Column(db.String(255), nullable=False) """ The ID of the media item on the external service """ service: ListService = db.Column(db.Enum(ListService), nullable=False) """ The service for which this object represents an ID """ media_user_states: List["MediaUserState"] = db.relationship( "MediaUserState", back_populates="media_id", cascade="all, delete") """ Media user states associated with this media ID """ chapter_guess: Optional["MangaChapterGuess"] = db.relationship( "MangaChapterGuess", uselist=False, back_populates="media_id", cascade="all, delete") """ Chapter Guess for this media ID (Only applicable if this is a manga title) """ @property def service_url(self) -> str: """ :return: The URL to the series for the given service """ url_format = list_service_url_formats[self.service] url = url_format \ .replace("@{media_type}", f"{self.media_type.value}") \ .replace("@{id}", self.service_id) return url @property def service_icon(self) -> str: """ :return: The path to the service's icon file """ return url_for( "static", filename=f"images/service_logos/{self.service.value}.png") @property def identifier_tuple(self) -> Tuple[MediaType, ListService, str]: """ :return: A tuple that uniquely identifies this database entry """ return self.media_type, self.service, self.service_id def update(self, new_data: "MediaId"): """ Updates the data in this record based on another object :param new_data: The object from which to use the new values :return: None """ self.media_item_id = new_data.media_item_id self.media_type = new_data.media_type self.service = new_data.service self.service_id = new_data.service_id
class Bet(ModelMixin, db.Model): """ Model that describes the 'bets' SQL table """ MAX_POINTS: int = 15 POSSIBLE_POINTS: List[int] = [0, 3, 7, 10, 12, 15] def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "bets" __table_args__ = (db.ForeignKeyConstraint( ("home_team_abbreviation", "away_team_abbreviation", "league", "season", "matchday"), (Match.home_team_abbreviation, Match.away_team_abbreviation, Match.league, Match.season, Match.matchday)), ) league: str = db.Column(db.String(255), primary_key=True) season: int = db.Column(db.Integer, primary_key=True) matchday: int = db.Column(db.Integer, primary_key=True) home_team_abbreviation: str = db.Column(db.String(3), primary_key=True) away_team_abbreviation: str = db.Column(db.String(3), primary_key=True) user_id: int = db.Column(db.Integer, db.ForeignKey("users.id"), primary_key=True) home_score: int = db.Column(db.Integer, nullable=False) away_score: int = db.Column(db.Integer, nullable=False) points: int = db.Column(db.Integer, nullable=True) user: User = db.relationship("User", backref=db.backref("bets", cascade="all, delete")) match: Match = db.relationship("Match", overlaps="bets") def __repr__(self) -> str: """ :return: A string with which the object may be generated """ params = "" for key, val in self.__json__().items(): if key == "points": continue params += "{}={}, ".format(key, repr(val)) params = params.rsplit(",", 1)[0] return "{}({})".format(self.__class__.__name__, params) def __eq__(self, other: Any) -> bool: """ Checks the model object for equality with another object :param other: The other object :return: True if the objects are equal, False otherwise """ if isinstance(other, Bet): return self.user_id == other.user_id \ and self.home_team_abbreviation == \ other.home_team_abbreviation \ and self.away_team_abbreviation == \ other.away_team_abbreviation \ and self.home_score == other.home_score \ and self.away_score == other.away_score else: return False # pragma: no cover def evaluate(self) -> Optional[int]: """ Evaluates the current points score on this bet :return: The calculated points (or None if the math hasn't started yet) """ if not self.match.has_started: return None points = 0 bet_diff = self.home_score - self.away_score match_diff = \ self.match.home_current_score - self.match.away_current_score if bet_diff == match_diff: # Correct goal difference points += 5 if bet_diff * match_diff > 0: # Correct winner points += 7 elif bet_diff == 0 and match_diff == 0: # Draw points += 7 if self.home_score == self.match.home_current_score \ or self.away_score == self.match.away_current_score: points += 3 return points
class User(IDModelMixin, db.Model): """ Model that describes the 'users' SQL table A User stores a user's information, including their email address, username and password hash """ __tablename__ = "users" """ The name of the table """ username: str = db.Column(db.String(Config.MAX_USERNAME_LENGTH), nullable=False, unique=True) """ The user's username """ email: str = db.Column(db.String(150), nullable=False, unique=True) """ The user's email address """ password_hash: str = db.Column(db.String(255), nullable=False) """ The user's hashed password, salted and hashed. """ confirmed: bool = db.Column(db.Boolean, nullable=False, default=False) """ The account's confirmation status. Logins should be impossible as long as this value is False. """ confirmation_hash: str = db.Column(db.String(255), nullable=False) """ The account's confirmation hash. This is the hash of a key emailed to the user. Only once the user follows the link in the email containing the key will their account be activated """ telegram_chat_id: Optional["TelegramChatId"] = db.relationship( "TelegramChatId", uselist=False, back_populates="user", cascade="all, delete") """ Telegram chat ID for the user if set up """ api_keys: List["ApiKey"] = db.relationship("ApiKey", back_populates="user", cascade="all, delete") """ API keys for this user """ @property def is_authenticated(self) -> bool: """ Property required by flask-login :return: True if the user is confirmed, False otherwise """ return True @property def is_anonymous(self) -> bool: """ Property required by flask-login :return: True if the user is not confirmed, False otherwise """ return not self.is_authenticated # pragma: no cover @property def is_active(self) -> bool: """ Property required by flask-login :return: True """ return self.confirmed def get_id(self) -> str: """ Method required by flask-login :return: The user's ID as a unicode string """ return str(self.id) def verify_password(self, password: str) -> bool: """ Verifies a password against the password hash :param password: The password to check :return: True if the password matches, False otherwise """ return verify_password(password, self.password_hash) def verify_confirmation(self, confirmation_key: str) -> bool: """ Verifies a confirmation key against the confirmation hash :param confirmation_key: The key to check :return: True if the key matches, False otherwise """ return verify_password(confirmation_key, self.confirmation_hash)
class ServiceUsername(ModelMixin, db.Model): """ Database model that stores an external service username for a user """ __tablename__ = "service_usernames" """ The name of the database table """ __table_args__ = (db.UniqueConstraint("user_id", "username", "service", name="unique_service_username"), ) """ Makes sure that objects that should be unique are unique """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) user_id: int = db.Column(db.Integer, db.ForeignKey("users.id", ondelete="CASCADE", onupdate="CASCADE"), nullable=False) """ The ID of the user associated with this service username """ user: User = db.relationship("User", backref=db.backref("service_usernames", lazy=True, cascade="all,delete")) """ The user associated with this service username """ username: str = db.Column(db.String(255), nullable=False) """ The service username """ service: ListService = db.Column(db.Enum(ListService), nullable=False) """ The external service this item is a username for """ @property def identifier_tuple(self) -> Tuple[int, str, ListService]: """ :return: A tuple that uniquely identifies this database entry """ return self.user_id, self.username, self.service def update(self, new_data: "ServiceUsername"): """ Updates the data in this record based on another object :param new_data: The object from which to use the new values :return: None """ self.user_id = new_data.user_id self.username = new_data.username self.service = new_data.service
class MediaUserState(ModelMixin, db.Model): """ Database model that keeps track of a user's entries on external services for a media item """ __tablename__ = "media_user_states" """ The name of the database table """ __table_args__ = (db.UniqueConstraint("media_id_id", "user_id", name="unique_media_user_state"), ) """ Makes sure that objects that should be unique are unique """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) media_id_id: int = db.Column(db.Integer, db.ForeignKey("media_ids.id"), nullable=False) """ The ID of the media ID referenced by this user state """ media_id: MediaId = db.relationship("MediaId", back_populates="media_user_states") """ The media ID referenced by this user state """ user_id: int = db.Column(db.Integer, db.ForeignKey("users.id", ondelete="CASCADE", onupdate="CASCADE"), nullable=False) """ The ID of the user associated with this user state """ user: User = db.relationship("User", backref=db.backref("media_user_states", lazy=True, cascade="all,delete")) """ The user associated with this user state """ progress: Optional[int] = db.Column(db.Integer, nullable=True) """ The user's current progress consuming the media item """ volume_progress: Optional[int] = db.Column(db.Integer, nullable=True) """ The user's current 'volume' progress. """ score: Optional[int] = db.Column(db.Integer, nullable=True) """ The user's score for the references media item """ consuming_state: ConsumingState \ = db.Column(db.Enum(ConsumingState), nullable=False) """ The current consuming state of the user for this media item """ media_notification: Optional["MediaNotification"] = db.relationship( "MediaNotification", uselist=False, back_populates="media_user_state", cascade="all, delete") """ Notification object for this user state """ @property def identifier_tuple(self) -> Tuple[int, int]: """ :return: A tuple that uniquely identifies this database entry """ return self.media_id_id, self.user_id def update(self, new_data: "MediaUserState"): """ Updates the data in this record based on another object :param new_data: The object from which to use the new values :return: None """ self.media_id_id = new_data.media_id_id self.user_id = new_data.user_id self.progress = new_data.progress self.volume_progress = new_data.volume_progress self.score = new_data.score self.consuming_state = new_data.consuming_state
class A(IDModelMixin, db.Model): __tablename__ = "a" s = db.Column(db.String(255))
class ReminderSettings(ModelMixin, db.Model): """ Database model that keeps track of reminder settings """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "reminder_settings" user_id: int = db.Column( db.Integer, db.ForeignKey("users.id"), primary_key=True ) reminder_type = db.Column(db.Enum(ReminderType), primary_key=True) active = db.Column(db.Boolean, nullable=False, default=True) reminder_time: int = db.Column(db.Integer, nullable=False, default=86400) last_reminder: str = db.Column(db.String(19), nullable=False, default="1970-01-01:01-01-01") user: User = db.relationship( "User", backref=db.backref("reminder_settings", cascade="all, delete") ) @property def reminder_time_delta(self) -> timedelta: """ :return: The 'reminder_time' parameter as a datetime timedelta """ return timedelta(seconds=self.reminder_time) @property def last_reminder_datetime(self) -> datetime: """ :return: The 'last_reminder' parameter as a datetime object """ return datetime.strptime(self.last_reminder, "%Y-%m-%d:%H-%M-%S") def set_reminder_time(self, reminder_time: int): """ Sets the reminder time and resets the time stored as the last reminder :param reminder_time: the new reminder time :return: None """ self.reminder_time = reminder_time self.last_reminder = "1970-01-01:01-01-01" db.session.commit() def get_due_matches(self) -> List[Match]: """ Checks if the reminder is due and returns a list of matches that the user still needs to bet on. :return: The matches for which the reminder is due """ now = datetime.utcnow() start = max(now, self.last_reminder_datetime) start_str = start.strftime("%Y-%m-%d:%H-%M-%S") then = now + self.reminder_time_delta then_str = then.strftime("%Y-%m-%d:%H-%M-%S") due_matches: List[Match] = [ x for x in Match.query.filter_by( season=Config.season(), league=Config.OPENLIGADB_LEAGUE ).all() if start_str < x.kickoff < then_str ] user_bet_matches = [ (bet.match.home_team_abbreviation, bet.match.away_team_abbreviation, bet.match.season) for bet in Bet.query.filter_by( user_id=self.user_id, season=Config.season(), league=Config.OPENLIGADB_LEAGUE ).options(db.joinedload(Bet.match)).all() ] to_remind = [] for match in due_matches: identifier = (match.home_team_abbreviation, match.away_team_abbreviation, match.season) if identifier not in user_bet_matches: to_remind.append(match) return to_remind def send_reminder(self): """ Sends a reminder message if it's due :return: None """ due = self.get_due_matches() if len(due) < 1: return else: app.logger.debug("Sending reminder to {}.".format(self.user.email)) message = render_template( "email/reminder.html", user=self.user, matches=due, hours=int(self.reminder_time / 3600) ) self.send_reminder_message(message) last_match = max(due, key=lambda x: x.kickoff) self.last_reminder = last_match.kickoff db.session.commit() def send_reminder_message(self, message: str): """ Sends a reminder message using the appropriate method of delivery :param message: The message to send :return: None """ if self.reminder_type == ReminderType.EMAIL: try: send_email( self.user.email, "Tippspiel Erinnerung", message, Config.SMTP_HOST, Config.SMTP_ADDRESS, Config.SMTP_PASSWORD, Config.SMTP_PORT ) except SMTPAuthenticationError: app.logger.error("Invalid SMTP settings, failed to send email") elif self.reminder_type == ReminderType.TELEGRAM: telegram = TelegramChatId.query.filter_by(user=self.user).first() if telegram is not None: message = BeautifulSoup(message, "html.parser").text message = "\n".join([x.strip() for x in message.split("\n")]) telegram.send_message(message)
class Tester(IDModelMixin, db.Model): enum = db.Column(db.Enum(A)) def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs)
class Match(ModelMixin, db.Model): """ Model that describes the 'matches' SQL table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "matches" league: str = db.Column(db.String(255), primary_key=True) season: int = db.Column(db.Integer, primary_key=True) matchday: int = db.Column(db.Integer, primary_key=True) home_team_abbreviation: str = db.Column( db.String(3), db.ForeignKey("teams.abbreviation"), primary_key=True, ) away_team_abbreviation: str = db.Column( db.String(3), db.ForeignKey("teams.abbreviation"), primary_key=True) home_current_score: int = db.Column(db.Integer, nullable=False) away_current_score: int = db.Column(db.Integer, nullable=False) home_ht_score: int = db.Column(db.Integer) away_ht_score: int = db.Column(db.Integer) home_ft_score: int = db.Column(db.Integer) away_ft_score: int = db.Column(db.Integer) kickoff: str = db.Column(db.String(255), nullable=False) started: bool = db.Column(db.Boolean, nullable=False) finished: bool = db.Column(db.Boolean, nullable=False) home_team: "Team" = db.relationship( "Team", foreign_keys=[home_team_abbreviation], ) away_team: "Team" = db.relationship("Team", foreign_keys=[away_team_abbreviation]) goals: List["Goal"] = db.relationship("Goal", cascade="all, delete") bets: List["Bet"] = db.relationship("Bet", cascade="all, delete") @property def minute_display(self) -> str: """ This generates a string for displaying the current match minute. Sadly, since OpenligaDB does not provide information on the current minute, this can only offer an approximation. :return: A formatted string displaying the current match minute """ delta = (datetime.utcnow() - self.kickoff_datetime).total_seconds() delta = int(delta / 60) if self.finished: return "Ende" elif 0 <= delta <= 44: return "{}.".format(delta + 1) elif 45 <= delta < 47: # buffer for ET return "45." elif 47 <= delta <= 64: return "HZ" elif 65 <= delta <= 109: return "{}.".format(delta - 65 + 1 + 45) elif delta >= 110: return "90." else: return "-" @property def current_score(self) -> str: """ :return: The current score formatted as a string """ return "{}:{}".format(self.home_current_score, self.away_current_score) @property def ht_score(self) -> str: """ :return: The half time score formatted as a string """ return "{}:{}".format(self.home_ht_score, self.away_ht_score) @property def ft_score(self) -> str: """ :return: The full time score formatted as a string """ return "{}:{}".format(self.home_ft_score, self.away_ft_score) @property def kickoff_datetime(self) -> datetime: """ :return: A datetime object representing the kickoff time """ return datetime.strptime(self.kickoff, "%Y-%m-%d:%H-%M-%S") @kickoff_datetime.setter def kickoff_datetime(self, kickoff: datetime): """ Setter for the kickoff datetime :param kickoff: The new kickoff datetime :return: None """ self.kickoff = kickoff.strftime("%Y-%m-%d:%H-%M-%S") @property def kickoff_local_datetime(self) -> datetime: """ :return: A datetime object representing the kickoff time in local time """ return self.kickoff_datetime.astimezone(pytz.timezone("europe/berlin")) @property def kickoff_time_string(self) -> str: """ :return: A string representing the kickoff time """ return self.kickoff_local_datetime.strftime("%H:%M") @property def kickoff_date_string(self) -> str: """ :return: A string representing the kickoff date """ return self.kickoff_local_datetime.strftime("%d. %m. %Y") @property def has_started(self) -> bool: """ Checks if the match has started. This is to be preferred over the 'started' attribute, just in case the database update has failed for any reason. :return: True if the match has started, False otherwise """ return self.started or self.kickoff_datetime <= datetime.utcnow() @property def url(self) -> str: """ :return: The URL for this match's info page """ return url_for("info.match", league=self.league, season=self.season, matchday=self.matchday, matchup=f"{self.home_team_abbreviation}_" f"{self.away_team_abbreviation}")
class ChatMessage(ModelMixin, db.Model): """ Model that describes the 'chat_messages' SQL table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "chat_messages" id: int = db.Column(db.Integer, primary_key=True, autoincrement=True) user_id: int = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True) parent_id: int = db.Column(db.Integer, db.ForeignKey("chat_messages.id"), nullable=True) text: str = db.Column(db.String(255), nullable=False) creation_time: float = db.Column(db.Float, nullable=False, default=time.time) last_edit: float = db.Column(db.Float, nullable=False, default=time.time) edited: bool = db.Column(db.Boolean, nullable=False, default=False) deleted: bool = db.Column(db.Boolean, nullable=False, default=False) user: Optional[User] = db.relationship("User", backref=db.backref("chat_messages")) parent: "ChatMessage" = db.relationship("ChatMessage", back_populates="children", remote_side=[id], uselist=False) children: List["ChatMessage"] = db.relationship("ChatMessage", back_populates="parent", uselist=True) def get_text(self) -> Optional[str]: """ :return: The text of the chat message if the user still exists and the message has not been deleted """ if self.deleted or self.user is None: return None else: return self.text def edit(self, new_text: str): """ Edits the message :param new_text: The new message text :return: None """ self.text = new_text self.edited = True self.last_edit = time.time() def delete(self): """ Marks the message as deleted :return: None """ self.text = "" self.deleted = True def __json__(self, include_children: bool = False, ignore_keys: Optional[List[str]] = None) -> Dict[str, Any]: """ Makes sure to include children and parents :param include_children: Whether or not to include child objects :param ignore_keys: Which keys to ignore :return: The JSON data """ data = super().__json__(include_children, ignore_keys) # TODO Add child and parent relations return data
class LeaderboardEntry(ModelMixin, db.Model): """ Model that describes the 'leaderboard_entries' SQL table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "leaderboard_entries" league: int = db.Column(db.String(255), primary_key=True) season: int = db.Column(db.Integer, primary_key=True) matchday: int = db.Column(db.Integer, primary_key=True) user_id: int = db.Column(db.Integer, db.ForeignKey("users.id"), primary_key=True) points: int = db.Column(db.Integer, nullable=False) position: int = db.Column(db.Integer, nullable=False) no_bot_position: int = db.Column(db.Integer, nullable=False) previous_position: int = db.Column(db.Integer, nullable=False) no_bot_previous_position: int = db.Column(db.Integer, nullable=False) user: User = db.relationship("User", backref=db.backref("leaderboard_entries", cascade="all, delete")) def get_position_info(self, include_bots: bool) -> Tuple[int, int]: """ Retrieves position info :param include_bots: Whether or not to include bots in the ranking :return: Current Position, Previous Position """ current = self.position if include_bots else self.no_bot_position previous = self.previous_position \ if include_bots else self.no_bot_previous_position return current, previous def get_tendency(self, include_bots: bool) -> str: """ Calculates the position tendency :param include_bots: Whether or not to include bots :return: The tendency as a string (example '+2') """ current, previous = self.get_position_info(include_bots) tendency = previous - current if tendency < 0: return str(tendency) elif tendency > 0: return f"+{tendency}" else: return "-" def get_tendency_class(self, include_bots: bool) -> str: """ Calculates the tendency and returns the corrsponding CSS class :param include_bots: Whether or not to include bots :return: The tendency CSS class name """ current, previous = self.get_position_info(include_bots) if current < previous: return "chevron-circle-up" elif current > previous: return "chevron-circle-down" else: return "minus-circle" @classmethod def load_history(cls, league: str, season: int, matchday: int) -> \ List[Tuple[User, List["LeaderboardEntry"]]]: """ Loads the history for the previous matches in a season for each user :param league: The league for which to retrieve the history :param season: The season for which to retrieve the history :param matchday: The matchday for which to retrieve the history :return: The history as a list of tuples of users and a list of the corresponding LeaderboardEntry objects. Sorted by current position """ entries: List[LeaderboardEntry] = [ x for x in LeaderboardEntry.query.filter_by( league=league, season=season).options( db.joinedload(LeaderboardEntry.user)).all() if x.matchday <= matchday ] entries.sort(key=lambda x: x.matchday) history_dict: Dict[int, List[LeaderboardEntry]] = {} for entry in entries: if entry.user_id not in history_dict: history_dict[entry.user_id] = [] history_dict[entry.user_id].append(entry) history_list = [(history[-1].user, history) for _, history in history_dict.items()] history_list.sort(key=lambda x: x[1][-1].position) return history_list
class MangaChapterGuess(ModelMixin, db.Model): """ Database model that keeps track of manga chapter guesses. """ __tablename__ = "manga_chapter_guesses" """ The name of the database table """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) media_id_id: int = db.Column( db.Integer, db.ForeignKey("media_ids.id"), nullable=False, unique=True ) """ The ID of the media ID referenced by this manga chapter guess """ media_id: MediaId = db.relationship( "MediaId", back_populates="chapter_guess" ) """ The media ID referenced by this manga chapter guess """ guess: int = db.Column(db.Integer, nullable=True) """ The actual guess for the most current chapter of the manga series """ last_update: int = db.Column(db.Integer, nullable=False, default=0) """ Timestamp from when the guess was last updated """ def update_guess(self): """ Updates the manga chapter guess (if the latest guess is older than an hour) :return: None """ delta = time.time() - self.last_update if delta > 60 * 60: self.last_update = int(time.time()) self.guess = guess_latest_manga_chapter( int(self.media_id.service_id) ) @property def identifier_tuple(self) -> Tuple[int]: """ :return: A tuple that uniquely identifies this database entry """ return self.media_id_id, def update(self, new_data: "MangaChapterGuess"): """ Updates the data in this record based on another object :param new_data: The object from which to use the new values :return: None """ self.media_id_id = new_data.media_id_id self.guess = new_data.guess self.last_update = new_data.last_update
class MediaListItem(ModelMixin, db.Model): """ Database model for media list items. This model maps MediaLists and MediaUserStates """ __tablename__ = "media_list_items" """ The name of the database table """ __table_args__ = (db.UniqueConstraint("media_list_id", "media_user_state_id", name="unique_media_list_item"), ) """ Makes sure that objects that should be unique are unique """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) media_list_id: int = db.Column(db.Integer, db.ForeignKey("media_lists.id"), nullable=False) """ The ID of the media list this list item is a part of """ media_list: MediaList = db.relationship("MediaList", back_populates="media_list_items") """ The media list this list item is a part of """ media_user_state_id: int = db.Column(db.Integer, db.ForeignKey("media_user_states.id", ondelete="CASCADE", onupdate="CASCADE"), nullable=False) """ The ID of the media user state this list item references """ media_user_state: MediaUserState = db.relationship( "MediaUserState", backref=db.backref("media_list_items", lazy=True, cascade="all,delete")) """ The media user state this list item references """ @property def identifier_tuple(self) -> Tuple[int, int]: """ :return: A tuple that uniquely identifies this database entry """ return self.media_list_id, self.media_user_state_id def update(self, new_data: "MediaListItem"): """ Updates the data in this record based on another object :param new_data: The object from which to use the new values :return: None """ self.media_list_id = new_data.media_list_id self.media_user_state_id = new_data.media_user_state_id
class Team(ModelMixin, db.Model): """ Model that describes the 'teams' SQL table A Team is the most basic data for a match, it relies on no other data, only primitives """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) __tablename__ = "teams" abbreviation: str = db.Column(db.String(3), primary_key=True) name: str = db.Column(db.String(50), nullable=False, unique=True) short_name: str = db.Column(db.String(16), nullable=False, unique=True) icon_svg: str = db.Column(db.String(255), nullable=False) icon_png: str = db.Column(db.String(255), nullable=False) players: List["Player"] = db.relationship("Player", cascade="all, delete") @property def home_matches(self) -> List[Match]: """ :return: A list of home matches for the team """ return Match.query.filter_by( home_team_abbreviation=self.abbreviation ).all() @property def away_matches(self) -> List[Match]: """ :return: A list of away matches for the team """ return Match.query.filter_by( away_team_abbreviation=self.abbreviation ).all() @property def matches(self) -> List[Match]: """ :return: A list of matches for the team """ return self.home_matches + self.away_matches @property def url(self) -> str: """ :return: The URL for this teams's info page """ return url_for("info.team", team_abbreviation=self.abbreviation) @classmethod def get_teams_for_season(cls, league: str, season: int) -> List["Team"]: """ Retrieves a list of all teams in a particular season :param league: The league in which to search for teams :param season: The season in which to search for teams :return: The list of teams """ match_samples = Match.query.filter_by( league=league, season=season, matchday=1 ).all() home_teams = [x.home_team for x in match_samples] away_teams = [x.away_team for x in match_samples] return home_teams + away_teams
class MediaItem(ModelMixin, db.Model): """ Database model for media items. These model a generic, site-agnostic representation of a series. """ __tablename__ = "media_items" """ The name of the database table """ __table_args__ = ( db.UniqueConstraint("media_type", "media_subtype", "romaji_title", name="unique_media_item_data"), db.UniqueConstraint("id", "media_type", "media_subtype", name="unique_media_item"), ) """ Makes sure that objects that should be unique are unique """ def __init__(self, *args, **kwargs): """ Initializes the Model :param args: The constructor arguments :param kwargs: The constructor keyword arguments """ super().__init__(*args, **kwargs) media_type: MediaType = db.Column(db.Enum(MediaType), nullable=False) """ The media type of the list item """ media_subtype: MediaSubType = db.Column(db.Enum(MediaSubType), nullable=False) """ The subtype (for example, TV short, movie oneshot etc) """ english_title: Optional[str] = db.Column(db.Unicode(255), nullable=True) """ The English title of the media item """ romaji_title: str = db.Column(db.Unicode(255), nullable=False) """ The Japanese title of the media item written in Romaji """ cover_url: str = db.Column(db.String(255), nullable=False) """ An URL to a cover image of the media item """ latest_release: Optional[int] = db.Column(db.Integer, nullable=True) """ The latest release chapter/episode for this media item """ latest_volume_release: Optional[int] = db.Column(db.Integer, nullable=True) """ The latest volume for this media item """ next_episode: Optional[int] = db.Column(db.Integer, nullable=True) """ The next episode to air """ next_episode_airing_time: Optional[int] = \ db.Column(db.Integer, nullable=True) """ The time the next episode airs """ releasing_state: ReleasingState = db.Column(db.Enum(ReleasingState), nullable=False) """ The current releasing state of the media item """ media_ids: List["MediaId"] = db.relationship("MediaId", back_populates="media_item", cascade="all, delete") """ Media IDs associated with this Media item """ ln_releases: List["LnRelease"] = db.relationship( "LnRelease", back_populates="media_item", cascade="all, delete") """ Light novel releases associated with this Media item """ @property def current_release(self) -> Optional[int]: """ The most current release, specifically tailored to the type of media :return: None """ if self.next_episode is not None: return self.next_episode - 1 elif self.latest_volume_release is not None: return self.latest_volume_release elif self.latest_release is not None: return self.latest_release else: return None @property def media_id_mapping(self) -> Dict[ListService, "MediaId"]: """ :return: A dictionary mapping list services to IDs for this media item """ return {x.service: x for x in self.media_ids} @property def identifier_tuple(self) -> Tuple[str, MediaType, MediaSubType]: """ :return: A tuple that uniquely identifies this database entry """ return self.romaji_title, self.media_type, self.media_subtype def update(self, new_data: "MediaItem"): """ Updates the data in this record based on another object :param new_data: The object from which to use the new values :return: None """ self.media_type = new_data.media_type self.media_subtype = new_data.media_subtype self.english_title = new_data.english_title self.romaji_title = new_data.romaji_title self.cover_url = new_data.cover_url self.latest_release = new_data.latest_release self.latest_volume_release = new_data.latest_volume_release self.releasing_state = new_data.releasing_state self.next_episode = new_data.next_episode self.next_episode_airing_time = new_data.next_episode_airing_time @property def title(self) -> str: """ :return: The default title for the media item. """ if self.english_title is None: return self.romaji_title else: return self.english_title @property def own_url(self) -> str: """ :return: The URL to the item's page on the otaku-info site """ return url_for("media.media", media_item_id=self.id) @property def next_episode_datetime(self) -> Optional[datetime]: """ :return: The datetime for when the next episode airs """ if self.next_episode_airing_time is None: return None else: return datetime.fromtimestamp(self.next_episode_airing_time)