191 lines
6.2 KiB
Python
191 lines
6.2 KiB
Python
from __future__ import annotations
|
|
|
|
from datetime import datetime, timezone
|
|
from typing import List, Optional
|
|
|
|
import pytz
|
|
from flask_sqlalchemy import SQLAlchemy
|
|
from flask import current_app
|
|
from sqlalchemy import (
|
|
Boolean,
|
|
Column,
|
|
DateTime,
|
|
String,
|
|
TypeDecorator,
|
|
ForeignKey,
|
|
UniqueConstraint,
|
|
)
|
|
from sqlalchemy.orm import Mapped, mapped_column, relationship
|
|
|
|
db: SQLAlchemy = SQLAlchemy()
|
|
|
|
deck_password = db.Table(
|
|
"deck_password",
|
|
Column("deck_id", db.Integer, db.ForeignKey("deck.id"), primary_key=True),
|
|
Column("password_id", db.Integer, db.ForeignKey("password.id"), primary_key=True),
|
|
)
|
|
|
|
deck_token = db.Table(
|
|
"deck_token",
|
|
Column("deck_id", db.Integer, db.ForeignKey("deck.id"), primary_key=True),
|
|
Column("token_id", db.Integer, db.ForeignKey("token.id"), primary_key=True),
|
|
)
|
|
|
|
|
|
class UTCDateTime(TypeDecorator):
|
|
impl = DateTime
|
|
|
|
def process_bind_param(self, value, dialect):
|
|
# Ensure datetime is stored in naive UTC
|
|
if value is not None and value.tzinfo is not None:
|
|
value = value.astimezone(pytz.utc).replace(tzinfo=None)
|
|
return value
|
|
|
|
def process_result_value(self, value, dialect):
|
|
# Re-attach UTC tzinfo when reading
|
|
if value is not None:
|
|
value = value.replace(tzinfo=pytz.utc)
|
|
return value
|
|
|
|
|
|
class Password(db.Model):
|
|
__tablename__ = "password"
|
|
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
|
value: Mapped[str] = mapped_column(String(60), unique=True)
|
|
expires_at: Mapped[Optional[datetime]] = mapped_column(
|
|
UTCDateTime()
|
|
) # Optional expiration
|
|
|
|
decks: Mapped[List[Deck]] = relationship(
|
|
"Deck", secondary=deck_password, back_populates="passwords"
|
|
)
|
|
|
|
def __init__(self, value: str, expires_at: datetime | None) -> None:
|
|
self.value = value
|
|
self.expires_at = expires_at
|
|
|
|
def is_expired(self) -> bool:
|
|
"""Check if the password is expired"""
|
|
return (
|
|
self.expires_at is not None and datetime.now(timezone.utc) > self.expires_at
|
|
)
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Password(value={self.value}, expires_at={self.expires_at})>"
|
|
|
|
|
|
class Deck(db.Model):
|
|
__tablename__ = "deck"
|
|
|
|
__table_args__ = (
|
|
UniqueConstraint("course_id", "deck", name="_course_deck_uc"),
|
|
UniqueConstraint("course_id", "name", name="_course_name_uc"),
|
|
)
|
|
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
|
name: Mapped[str] = mapped_column(String(60), nullable=False)
|
|
deck: Mapped[str] = mapped_column(String(60), nullable=False)
|
|
description: Mapped[str] = mapped_column(String(200))
|
|
index_file: Mapped[str] = mapped_column(String(40), nullable=False)
|
|
export_file: Mapped[Optional[str]] = mapped_column(String(40), nullable=True)
|
|
|
|
passwords: Mapped[List[Password]] = relationship(
|
|
"Password", secondary=deck_password, back_populates="decks"
|
|
)
|
|
tokens: Mapped[List[Token]] = relationship(
|
|
"Token", secondary=deck_token, back_populates="decks"
|
|
)
|
|
course_id: Mapped[int] = mapped_column(ForeignKey("course.id"))
|
|
course: Mapped["Course"] = relationship("Course", back_populates="decks")
|
|
|
|
def __init__(
|
|
self,
|
|
name: str,
|
|
deck: str,
|
|
course: Course,
|
|
description: str = "",
|
|
index_file: str = "index.html",
|
|
export_file: str | None = None,
|
|
) -> None:
|
|
self.name = name
|
|
self.deck = deck
|
|
self.description = description
|
|
self.course = course
|
|
self.index_file = index_file
|
|
if export_file:
|
|
self.export_file = export_file
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Deck(name={self.name}, deck={self.deck}, course={self.course}, index={self.index_file})>"
|
|
|
|
|
|
class Token(db.Model):
|
|
__tablename__ = "token"
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
|
name: Mapped[str] = mapped_column(String(60), unique=True, nullable=False)
|
|
created_at: Mapped[datetime] = mapped_column(UTCDateTime(), nullable=False)
|
|
active_course_id: Mapped[int] = mapped_column(
|
|
ForeignKey("course.id"), nullable=True
|
|
)
|
|
active_course: Mapped[Course] = relationship(
|
|
"Course", foreign_keys=[active_course_id]
|
|
)
|
|
decks: Mapped[List[Deck]] = relationship(
|
|
"Deck", secondary=deck_token, back_populates="tokens"
|
|
)
|
|
|
|
def __init__(self, name: str) -> None:
|
|
self.name = name
|
|
self.created_at = datetime.now(timezone.utc)
|
|
self.active_course_id = current_app.config["DEFAULT_COURSE"]
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Token(id={self.id}, name={self.name}, active_course_id={self.active_course_id})>"
|
|
|
|
def is_unlocked(self, deck: str) -> bool:
|
|
return deck in [deck.deck for deck in self.decks]
|
|
|
|
|
|
class Course(db.Model):
|
|
__tablename__ = "course"
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
|
folder: Mapped[str] = mapped_column(String(20), unique=True, nullable=False)
|
|
name: Mapped[str] = mapped_column(String(60), unique=True, nullable=False)
|
|
decks: Mapped[List["Deck"]] = relationship(back_populates="course")
|
|
|
|
def __init__(self, name: str, folder: str) -> None:
|
|
self.name = name
|
|
self.folder = folder
|
|
|
|
def __repr__(self) -> str:
|
|
return f"<Course(id={self.id}, name={self.name})>"
|
|
|
|
|
|
class InfoBanner(db.Model):
|
|
__tablename__ = "info_banner"
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
|
content: Mapped[str] = mapped_column(String(280))
|
|
is_active: Mapped[bool] = mapped_column(Boolean)
|
|
|
|
def __init__(self, content: str) -> None:
|
|
self.content = content
|
|
self.is_active = False
|
|
|
|
|
|
class PageView(db.Model):
|
|
__tablename__ = "page_view"
|
|
|
|
id: Mapped[int] = mapped_column(primary_key=True)
|
|
deck_id: Mapped[int] = mapped_column(ForeignKey("deck.id"), nullable=False)
|
|
token_id: Mapped[int] = mapped_column(ForeignKey("token.id"), nullable=False)
|
|
viewed_at: Mapped[datetime] = mapped_column(UTCDateTime(), nullable=False)
|
|
|
|
deck: Mapped["Deck"] = relationship("Deck")
|
|
token: Mapped["Token"] = relationship("Token")
|
|
|
|
def __init__(self, deck_id: int, token_id: int) -> None:
|
|
self.deck_id = deck_id
|
|
self.token_id = token_id
|
|
self.viewed_at = datetime.now(timezone.utc)
|