feat(playlists): implement Playlist and PlaylistSound models; add seeding for default Main playlist

app/models/playlist_sound.py

@@ -0,0 +1,188 @@
+"""Playlist-Sound relationship model for managing sound order in playlists."""
+
+from datetime import datetime
+from typing import TYPE_CHECKING, Optional
+from zoneinfo import ZoneInfo
+
+from sqlalchemy import DateTime, ForeignKey, Integer, UniqueConstraint
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.database import db
+
+if TYPE_CHECKING:
+    from app.models.playlist import Playlist
+    from app.models.sound import Sound
+
+
+class PlaylistSound(db.Model):
+    """Model for playlist-sound relationships with ordering."""
+
+    __tablename__ = "playlist_sounds"
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True)
+    playlist_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("playlists.id"), nullable=False
+    )
+    sound_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey("sounds.id"), nullable=False
+    )
+    order: Mapped[int] = mapped_column(Integer, nullable=False)
+    added_at: Mapped[datetime] = mapped_column(
+        DateTime,
+        default=lambda: datetime.now(tz=ZoneInfo("UTC")),
+        nullable=False,
+    )
+
+    # Relationships
+    playlist: Mapped["Playlist"] = relationship(
+        "Playlist", back_populates="playlist_sounds"
+    )
+    sound: Mapped["Sound"] = relationship(
+        "Sound", back_populates="playlist_sounds"
+    )
+
+    # Constraints
+    __table_args__ = (
+        UniqueConstraint(
+            "playlist_id", "sound_id", name="unique_playlist_sound"
+        ),
+        UniqueConstraint("playlist_id", "order", name="unique_playlist_order"),
+    )
+
+    def __repr__(self) -> str:
+        """String representation of the playlist-sound relationship."""
+        return f"<PlaylistSound(playlist_id={self.playlist_id}, sound_id={self.sound_id}, order={self.order})>"
+
+    def to_dict(self) -> dict:
+        """Convert playlist-sound relationship to dictionary representation."""
+        return {
+            "id": self.id,
+            "playlist_id": self.playlist_id,
+            "sound_id": self.sound_id,
+            "order": self.order,
+            "added_at": self.added_at.isoformat() if self.added_at else None,
+            "sound": self.sound.to_dict() if self.sound else None,
+        }
+
+    @classmethod
+    def create_playlist_sound(
+        cls,
+        playlist_id: int,
+        sound_id: int,
+        order: int,
+        commit: bool = True,
+    ) -> "PlaylistSound":
+        """Create a new playlist-sound relationship."""
+        playlist_sound = cls(
+            playlist_id=playlist_id,
+            sound_id=sound_id,
+            order=order,
+        )
+
+        db.session.add(playlist_sound)
+        if commit:
+            db.session.commit()
+
+        return playlist_sound
+
+    @classmethod
+    def find_by_playlist(cls, playlist_id: int) -> list["PlaylistSound"]:
+        """Find all sounds in a playlist ordered by their position."""
+        return (
+            cls.query.filter_by(playlist_id=playlist_id)
+            .order_by(cls.order)
+            .all()
+        )
+
+    @classmethod
+    def find_by_sound(cls, sound_id: int) -> list["PlaylistSound"]:
+        """Find all playlists containing a specific sound."""
+        return cls.query.filter_by(sound_id=sound_id).all()
+
+    @classmethod
+    def find_by_playlist_and_sound(
+        cls, playlist_id: int, sound_id: int
+    ) -> Optional["PlaylistSound"]:
+        """Find a specific playlist-sound relationship."""
+        return cls.query.filter_by(
+            playlist_id=playlist_id, sound_id=sound_id
+        ).first()
+
+    @classmethod
+    def get_next_order(cls, playlist_id: int) -> int:
+        """Get the next order number for a playlist."""
+        max_order = (
+            db.session.query(db.func.max(cls.order))
+            .filter_by(playlist_id=playlist_id)
+            .scalar()
+        )
+        return (max_order or 0) + 1
+
+    @classmethod
+    def reorder_playlist(
+        cls, playlist_id: int, sound_orders: list[dict], commit: bool = True
+    ) -> None:
+        """Reorder all sounds in a playlist.
+
+        Args:
+            playlist_id: ID of the playlist
+            sound_orders: List of dicts with 'sound_id' and 'order' keys
+        """
+        for item in sound_orders:
+            playlist_sound = cls.query.filter_by(
+                playlist_id=playlist_id, sound_id=item["sound_id"]
+            ).first()
+            if playlist_sound:
+                playlist_sound.order = item["order"]
+
+        if commit:
+            db.session.commit()
+
+    def move_to_position(self, new_order: int, commit: bool = True) -> None:
+        """Move this sound to a new position in the playlist."""
+        old_order = self.order
+
+        if new_order == old_order:
+            return
+
+        # Get all other sounds in the playlist
+        other_sounds = (
+            PlaylistSound.query.filter_by(playlist_id=self.playlist_id)
+            .filter(PlaylistSound.id != self.id)
+            .order_by(PlaylistSound.order)
+            .all()
+        )
+
+        # Remove this sound from its current position
+        remaining_sounds = [ps for ps in other_sounds if ps.order != old_order]
+
+        # Insert at new position
+        if new_order <= len(remaining_sounds):
+            remaining_sounds.insert(new_order - 1, self)
+        else:
+            remaining_sounds.append(self)
+
+        # Update all order values
+        for i, ps in enumerate(remaining_sounds, 1):
+            ps.order = i
+
+        if commit:
+            db.session.commit()
+
+    def get_previous_sound(self) -> Optional["PlaylistSound"]:
+        """Get the previous sound in the playlist."""
+        return (
+            PlaylistSound.query.filter_by(playlist_id=self.playlist_id)
+            .filter(PlaylistSound.order < self.order)
+            .order_by(PlaylistSound.order.desc())
+            .first()
+        )
+
+    def get_next_sound(self) -> Optional["PlaylistSound"]:
+        """Get the next sound in the playlist."""
+        return (
+            PlaylistSound.query.filter_by(playlist_id=self.playlist_id)
+            .filter(PlaylistSound.order > self.order)
+            .order_by(PlaylistSound.order.asc())
+            .first()
+        )