artemis-model 0.1.66__py3-none-any.whl

artemis_model/genre.py

@@ -0,0 +1,52 @@
+
+from sqlalchemy import Computed, func, literal, text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from artemis_model.base import CustomBase, CustomSyncBase, TSVector, TimeStampMixin
+
+from sqlalchemy.ext.declarative import declared_attr
+
+
+def to_tsvector_ix(*columns):
+    s = " || ' ' || ".join(columns)
+    return func.to_tsvector(literal("english"), text(s))
+
+
+class GenreMixin(TimeStampMixin):
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+    parent_id: Mapped[int | None] = mapped_column(nullable=True)
+    disabled: Mapped[bool] = mapped_column(nullable=False, default=False)
+    legacy_id: Mapped[str] = mapped_column(nullable=False)
+
+    name_tsv = mapped_column(
+        TSVector(),
+        Computed("to_tsvector('english', name)", persisted=True),
+    )
+
+    @declared_attr
+    def tracks(cls) -> Mapped[list["Track"]]:
+        return relationship(
+            "Track", secondary="track_genre_assoc", back_populates="genres"
+        )
+
+    @declared_attr
+    def dj_set_genre_associations(cls) -> Mapped[list["DjSetGenreAssoc"]]:
+        return relationship(
+            back_populates="genre", cascade="all, delete-orphan"
+        )
+
+    def dj_sets(cls) -> Mapped[list["DjSet"]]:
+        return relationship("DjSet", secondary="dj_set_genre_assoc", back_populates="genre")
+
+    # __table_args__ = (
+    #     Index("fts_ix_genre_name_tsv", to_tsvector_ix("name"), postgresql_using="gin"),
+    # )
+
+
+class GenreSync(CustomSyncBase, GenreMixin):
+    pass
+
+
+class Genre(CustomBase, GenreMixin):
+    pass

artemis_model/location.py

@@ -0,0 +1,154 @@
+import uuid
+from typing import Any, List
+
+from slugify import slugify
+from sqlalchemy import UUID, ForeignKey
+from sqlalchemy.event import listen
+from sqlalchemy.ext.associationproxy import AssociationProxy, association_proxy
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from artemis_model.base import TimeStampMixin, CustomSyncBase, CustomBase
+
+from sqlalchemy.ext.declarative import declared_attr
+
+
+class AddressMixin:
+    id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True)
+    street: Mapped[str] = mapped_column(nullable=False)
+    street2: Mapped[str] = mapped_column(nullable=True)
+    city: Mapped[str] = mapped_column(nullable=False)
+    state: Mapped[str] = mapped_column(nullable=False)
+    zip_code: Mapped[str] = mapped_column(nullable=False)
+    country: Mapped[str] = mapped_column(nullable=False)
+
+    @declared_attr
+    def location(cls) -> Mapped["Location"]:
+        return relationship(
+            uselist=False,
+            back_populates="address",
+        )
+
+
+class AddressSync(CustomSyncBase, AddressMixin):
+    pass
+
+
+class Address(CustomBase, AddressMixin):
+    pass
+
+
+class LocationMixin(TimeStampMixin):
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    name: Mapped[str] = mapped_column(nullable=False)
+    slug: Mapped[str] = mapped_column(nullable=False)
+    organization_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("organization.id"), nullable=False, index=True
+    )
+    location_type: Mapped[str] = mapped_column(nullable=True)
+    disabled: Mapped[bool] = mapped_column(nullable=False, default=False)
+    group_id: Mapped[int | None] = mapped_column(
+        ForeignKey("location_group.id"), nullable=True, index=True
+    )
+
+    address_id = mapped_column(ForeignKey("address.id"), nullable=True)
+    legacy_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), nullable=True)
+
+    @declared_attr
+    def organization(cls) -> Mapped["Organization"]:
+        return relationship(back_populates="locations")
+
+    @declared_attr
+    def group(cls) -> Mapped["LocationGroup"]:
+        return relationship(back_populates="locations")
+
+    @declared_attr
+    def zones(cls) -> Mapped[list["Zone"]]:
+        return relationship(back_populates="location")
+
+    @declared_attr
+    def users(cls) -> AssociationProxy[list["User"]]:
+        return association_proxy(
+            "user_location_associations",
+            "user",
+            creator=lambda user_id: UserLocationAssoc(user_id=user_id),
+        )
+
+    @declared_attr
+    def address(cls) -> Mapped["Address"]:
+        return relationship(
+            uselist=False,
+            back_populates="location",
+        )
+
+    @declared_attr
+    def user_location_associations(cls) -> Mapped[list["UserLocationAssoc"]]:
+        return relationship(
+            cascade="all, delete-orphan",
+        )
+
+    timezone: Mapped[str] = mapped_column(nullable=False, default="America/New_York")
+
+
+def generate_slug(target: Any, value: Any, old_value: Any, initiator: Any) -> None:
+    """Creates a reasonable slug based on location name."""
+    if value and (not target.slug or value != old_value):
+        target.slug = slugify(value, separator="_")
+
+
+class LocationSync(CustomSyncBase, LocationMixin):
+    pass
+
+
+listen(LocationSync.name, "set", generate_slug)
+
+
+class Location(CustomBase, LocationMixin):
+    pass
+
+
+listen(Location.name, "set", generate_slug)
+
+
+class LocationGroupMixin(TimeStampMixin):
+    id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True)
+    organization_id = mapped_column(
+        ForeignKey("organization.id"), nullable=False, index=True
+    )
+    name: Mapped[str] = mapped_column(nullable=False)
+    description: Mapped[str] = mapped_column(nullable=True)
+    disabled: Mapped[bool] = mapped_column(nullable=False, default=False)
+
+    @declared_attr
+    def locations(cls) -> Mapped[List["Location"]]:
+        return relationship(
+            back_populates="group",
+        )
+
+
+class LocationGroupSync(CustomSyncBase, LocationGroupMixin):
+    pass
+
+
+class LocationGroup(CustomBase, LocationGroupMixin):
+    pass
+
+
+class UserLocationAssocMixin(TimeStampMixin):
+    location_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("location.id"), primary_key=True
+    )
+    user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("user.id"), primary_key=True)
+
+    @declared_attr
+    def user(cls) -> Mapped["User"]:
+        return relationship(back_populates="user_location_associations")
+
+
+class UserLocationAssocSync(CustomSyncBase, UserLocationAssocMixin):
+    pass
+
+
+class UserLocationAssoc(CustomBase, UserLocationAssocMixin):
+    pass

artemis_model/message.py

@@ -0,0 +1,97 @@
+import uuid
+from typing import List
+from sqlalchemy import JSON, ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from artemis_model.base import CustomSyncBase, TimeStampMixin, AuditMixin, CustomBase
+
+from sqlalchemy.ext.declarative import declared_attr
+
+
+class MessageMixin(TimeStampMixin, AuditMixin):
+    """
+    This table is used to store the message.
+    """
+    id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True, index=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+    disabled: Mapped[bool] = mapped_column(nullable=False, default=False)
+    s3_link: Mapped[str] = mapped_column(nullable=False)
+
+    organization_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("organization.id"), nullable=False, index=True)
+    message_group_id: Mapped[int] = mapped_column(ForeignKey("message_group.id"), nullable=True, index=True, default=None)
+
+    @declared_attr
+    def organization(cls) -> Mapped["Organization"]:
+        return relationship("Organization", back_populates="messages")
+
+    @declared_attr
+    def message_group(cls) -> Mapped["MessageGroup"]:
+        return relationship("MessageGroup", back_populates="messages")
+
+    @declared_attr
+    def play_details(cls) -> Mapped[List["MessagePlayDetail"]]:
+        return relationship("MessagePlayDetail", back_populates="message")
+
+
+class MessageSync(CustomSyncBase, MessageMixin):
+    pass
+
+
+class Message(CustomBase, MessageMixin):
+    pass
+
+
+class MessagePlayDetailMixin(TimeStampMixin, AuditMixin):
+    """
+    This table is used to store the message play details.
+    Frequency is used only for rotated messages.
+    Timesheet is used only for scheduled messages.
+    """
+    id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True, index=True)
+    message_id: Mapped[int] = mapped_column(ForeignKey("message.id"), nullable=False, index=True)
+    zone_id: Mapped[int] = mapped_column(ForeignKey("zone.id"), index=True)
+
+    type: Mapped[str] = mapped_column(nullable=False)
+
+    timesheet: Mapped[JSON] = mapped_column(JSON, nullable=True)
+
+    @declared_attr
+    def message(cls) -> Mapped["Message"]:
+        return relationship("Message", back_populates="play_details")
+
+    @declared_attr
+    def zone(cls) -> Mapped["Zone"]:
+        return relationship("Zone", back_populates="message_play_details")
+
+
+class MessagePlayDetailSync(CustomSyncBase, MessagePlayDetailMixin):
+    pass
+
+
+class MessagePlayDetail(CustomBase, MessagePlayDetailMixin):
+    pass
+
+
+class MessageGroupMixin(TimeStampMixin, AuditMixin):
+    """
+    This table is used to store the message group.
+    """
+    id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True, index=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+    organization_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("organization.id"), nullable=False, index=True)
+
+    @declared_attr
+    def organization(cls) -> Mapped["Organization"]:
+        return relationship("Organization", back_populates="message_groups")
+
+    @declared_attr
+    def messages(cls) -> Mapped[List["Message"]]:
+        return relationship(back_populates="message_group")
+
+
+class MessageGroupSync(CustomSyncBase, MessageGroupMixin):
+    pass
+
+
+class MessageGroup(CustomBase, MessageGroupMixin):
+    pass

artemis_model/organization.py

@@ -0,0 +1,78 @@
+import uuid
+from typing import Any, List
+
+from slugify import slugify
+from sqlalchemy import UUID, ForeignKey
+from sqlalchemy.event import listen
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from artemis_model.base import CustomSyncBase, TimeStampMixin, CustomBase
+
+from sqlalchemy.ext.declarative import declared_attr
+
+
+class OrganizationMixin(TimeStampMixin):
+    id: Mapped[uuid.UUID] = mapped_column(
+        UUID(as_uuid=True), primary_key=True, default=uuid.uuid4
+    )
+    name: Mapped[str] = mapped_column(nullable=False)
+    description: Mapped[str | None] = mapped_column(nullable=True)
+    slug: Mapped[str] = mapped_column(nullable=False, index=True)
+    disabled: Mapped[bool] = mapped_column(nullable=False, default=False)
+
+    @declared_attr
+    def locations(cls) -> Mapped[List["Location"]]:
+        return relationship(back_populates="organization")
+
+    @declared_attr
+    def dj_sets(cls) -> Mapped[List["DjSet"]]:
+        return relationship(back_populates="organization")
+
+    @declared_attr
+    def users(cls) -> Mapped[List["User"]]:
+        return relationship(
+            secondary="organization_user_assoc", back_populates="organizations"
+        )
+
+    @declared_attr
+    def messages(cls) -> Mapped[List["Message"]]:
+        return relationship(back_populates="organization")
+
+    @declared_attr
+    def message_groups(cls) -> Mapped[List["MessageGroup"]]:
+        return relationship(back_populates="organization")
+
+
+def generate_slug(target: Any, value: Any, old_value: Any, initiator: Any) -> None:
+    """Creates a reasonable slug based on organization name."""
+    if value and (not target.slug or value != old_value):
+        target.slug = slugify(value, separator="_")
+
+
+class OrganizationSync(CustomSyncBase, OrganizationMixin):
+    pass
+
+
+listen(OrganizationSync.name, "set", generate_slug)
+
+
+class Organization(CustomBase, OrganizationMixin):
+    pass
+
+
+listen(Organization.name, "set", generate_slug)
+
+
+class OrganizationUserAssocMixin(TimeStampMixin):
+    organization_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("organization.id"), primary_key=True
+    )
+    user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("user.id"), primary_key=True)
+
+
+class OrganizationUserAssocSync(CustomSyncBase, OrganizationUserAssocMixin):
+    pass
+
+
+class OrganizationUserAssoc(CustomBase, OrganizationUserAssocMixin):
+    pass

artemis_model/otp.py

@@ -0,0 +1,34 @@
+
+import uuid
+from datetime import datetime
+from sqlalchemy.orm import Mapped, mapped_column
+
+from artemis_model.base import TimeStampMixin, CustomBase, CustomSyncBase
+
+
+class OtpMixin(TimeStampMixin):
+    """
+    This table is used to store the OTPs.
+    requested_by can be an UserAccount or UserUnverifiedAccount id.
+    """
+
+    id: Mapped[int] = mapped_column(
+        primary_key=True, autoincrement=True, nullable=False
+    )
+    code: Mapped[str] = mapped_column(nullable=False)
+    purpose: Mapped[str] = mapped_column(nullable=False)
+    requested_by_id: Mapped[uuid.UUID] = mapped_column(nullable=False, index=True)
+    method: Mapped[str] = mapped_column(nullable=False, index=True)
+    secret: Mapped[str] = mapped_column(nullable=False)
+    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow, index=True)
+    updated_at: Mapped[datetime] = mapped_column(
+        default=datetime.utcnow, onupdate=datetime.utcnow
+    )
+
+
+class OtpSync(CustomSyncBase, OtpMixin):
+    pass
+
+
+class Otp(CustomBase, OtpMixin):
+    pass

artemis_model/permission.py

@@ -0,0 +1,53 @@
+import uuid
+from typing import List
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from artemis_model.base import TimeStampMixin, CustomSyncBase, CustomBase
+
+from sqlalchemy.ext.declarative import declared_attr
+
+
+class PermissionMixin(TimeStampMixin):
+    id: Mapped[str] = mapped_column(
+         primary_key=True
+    )
+    name: Mapped[str] = mapped_column(nullable=False)
+    description: Mapped[str] = mapped_column(nullable=False)
+    type: Mapped[str] = mapped_column(nullable=False)  # music-management, player-management, user-management
+
+    @declared_attr
+    def user_permission_associations(cls) -> Mapped[List["UserPermissionAssoc"]]:
+        return relationship(
+            back_populates="permission", cascade="all, delete-orphan"
+        )
+
+
+class UserPermissionAssocMixin(TimeStampMixin):
+    user_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("user.id"), primary_key=True
+    )
+    permission_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("permission.id"), primary_key=True
+    )
+
+    @declared_attr
+    def permission(cls) -> Mapped["Permission"]:
+        return relationship(back_populates="user_permission_associations")
+
+
+class UserPermissionAssocSync(CustomSyncBase, UserPermissionAssocMixin):
+    pass
+
+
+class UserPermissionAssoc(CustomBase, UserPermissionAssocMixin):
+    pass
+
+
+class PermissionSync(CustomSyncBase, PermissionMixin):
+    pass
+
+
+class Permission(CustomBase, PermissionMixin):
+    pass

artemis_model/playlist.py

@@ -0,0 +1,191 @@
+import uuid
+from datetime import date, datetime
+
+from sqlalchemy import Computed, ForeignKey, func, literal, text
+from sqlalchemy.ext.associationproxy import AssociationProxy, association_proxy
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from artemis_model.base import CustomBase, CustomSyncBase, TSVector, TimeStampMixin
+
+from sqlalchemy.ext.declarative import declared_attr
+
+
+def to_tsvector_ix(*columns):
+    s = " || ' ' || ".join(columns)
+    return func.to_tsvector(literal("english"), text(s))
+
+
+class PlaylistMixin(TimeStampMixin):
+    id: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str] = mapped_column(nullable=False, unique=True)
+    entry_date: Mapped[datetime] = mapped_column(
+        nullable=False, default=datetime.utcnow
+    )
+    disabled: Mapped[bool] = mapped_column(nullable=False, default=False)
+    legacy_id: Mapped[str] = mapped_column(nullable=True)
+    is_published: Mapped[bool] = mapped_column(default=False)  # legacy isTest
+    description: Mapped[str | None] = mapped_column(nullable=True)
+    cover_image: Mapped[str | None] = mapped_column(nullable=True)
+    is_ordered: Mapped[bool] = mapped_column(
+        default=False
+    )  # CanBeShuffled - Migration'da tersini al
+    legacy_prepared_by: Mapped[str | None] = mapped_column(nullable=True)
+    notes: Mapped[str | None] = mapped_column(nullable=True)
+    published_at: Mapped[date | None] = mapped_column(nullable=True)
+    is_private: Mapped[bool] = mapped_column(default=False)
+
+    name_tsv = mapped_column(
+        TSVector(),
+        Computed("to_tsvector('english', name)", persisted=True),
+    )
+
+    @declared_attr
+    def category_playlist_associations(cls) -> Mapped[
+        list["PlaylistCategoryAssoc"]
+    ]:
+        return relationship(cascade="all, delete-orphan")
+
+    @declared_attr
+    def track_playlist_associations(cls) -> Mapped[list["PlaylistTrackAssoc"]]:
+        return relationship(
+            cascade="all, delete-orphan"
+        )
+
+    @declared_attr
+    def organization_playlist_associations(cls) -> Mapped[
+        list["PlaylistOrganizationAssoc"]
+    ]:
+        return relationship(cascade="all, delete-orphan")
+
+    @declared_attr
+    def organization_ids(cls) -> AssociationProxy[list["Organization"] | None]:
+        return association_proxy(
+            "organization_playlist_associations",
+            "organization",
+            creator=lambda o: PlaylistOrganizationAssoc(organization_id=o),
+        )
+
+    @declared_attr
+    def category_ids(cls) -> AssociationProxy[list["Category"] | None]:
+        return association_proxy(
+            "category_playlist_associations",
+            "category",
+            creator=lambda c: PlaylistCategoryAssoc(category_id=c),
+        )
+
+    @declared_attr
+    def track_ids(cls) -> AssociationProxy[list["Track"] | None]:
+        return association_proxy(
+            "track_playlist_associations",
+            "track",
+            creator=lambda t: PlaylistTrackAssoc(track_id=t),
+        )
+
+    @declared_attr
+    def tracks(cls) -> Mapped[list["Track"]]:
+        return relationship(
+            secondary="playlist_track_assoc", viewonly=True
+        )
+
+    @declared_attr
+    def categories(cls) -> Mapped[list["Category"]]:
+        return relationship(
+            secondary="playlist_category_assoc", viewonly=True
+        )
+
+    @property
+    def total_duration(self) -> int:
+        return sum([0 if not t.duration else t.duration for t in self.tracks], 0)
+
+    # __table_args__ = (
+    #     Index(
+    #         "fts_ix_playlist_name_tsv",
+    #         to_tsvector_ix("name"),
+    #         postgresql_using="gin",
+    #     ),
+    # )
+
+
+class PlaylistSync(CustomSyncBase, PlaylistMixin):
+    pass
+
+
+class Playlist(CustomBase, PlaylistMixin):
+    pass
+
+
+class PlaylistOrganizationAssocMixin(TimeStampMixin):
+    playlist_id: Mapped[int] = mapped_column(
+        ForeignKey("playlist.id"), primary_key=True, nullable=False
+    )
+    organization_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("organization.id"), primary_key=True, nullable=False
+    )
+
+
+class PlaylistOrganizationkAssocSync(CustomSyncBase, PlaylistOrganizationAssocMixin):
+    pass
+
+
+class PlaylistOrganizationAssoc(CustomBase, PlaylistOrganizationAssocMixin):
+    pass
+
+
+class PlaylistTrackAssocMixin(TimeStampMixin):
+    playlist_id: Mapped[int] = mapped_column(
+        ForeignKey("playlist.id"), primary_key=True, nullable=False
+    )
+    track_id: Mapped[uuid.UUID] = mapped_column(
+        ForeignKey("track.id"), primary_key=True, nullable=False
+    )
+
+    @declared_attr
+    def track(cls) -> Mapped["Track"]:
+        return relationship(back_populates="track_playlist_associations")
+
+
+class PlaylistTrackAssocSync(CustomSyncBase, PlaylistTrackAssocMixin):
+    pass
+
+
+class PlaylistTrackAssoc(CustomBase, PlaylistTrackAssocMixin):
+    pass
+
+
+class PlaylistCategoryAssocMixin(TimeStampMixin):
+    playlist_id = mapped_column(
+        ForeignKey("playlist.id"), primary_key=True, nullable=False
+    )
+    category_id: Mapped[int] = mapped_column(
+        ForeignKey("category.id"), primary_key=True, nullable=False
+    )
+
+    @declared_attr
+    def category(cls) -> Mapped["Category"]:
+        return relationship(
+            back_populates="category_playlist_associations"
+        )
+
+
+class PlaylistCategoryAssocSync(CustomSyncBase, PlaylistCategoryAssocMixin):
+    pass
+
+
+class PlaylistCategoryAssoc(CustomBase, PlaylistCategoryAssocMixin):
+    pass
+
+
+class PlaylistCounterMixin:
+    playlist_id: Mapped[int] = mapped_column(
+        ForeignKey("playlist.id"), primary_key=True, nullable=False
+    )
+    play_count: Mapped[int] = mapped_column(default=0)
+    schedule_count: Mapped[int] = mapped_column(default=0)
+
+
+class PlaylistCounterSync(CustomSyncBase, PlaylistCounterMixin):
+    pass
+
+
+class PlaylistCounter(CustomBase, PlaylistCounterMixin):
+    pass

artemis_model/schedule.py

@@ -0,0 +1,35 @@
+import uuid
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+from sqlalchemy.types import JSON, UUID
+
+from artemis_model.base import CustomBase, TimeStampMixin, AuditMixin, CustomSyncBase
+
+from sqlalchemy.ext.declarative import declared_attr
+
+
+class ScheduleMixin(TimeStampMixin, AuditMixin):
+    """
+    This table is used to store the schedule of a zone.
+    """
+
+    id: Mapped[int] = mapped_column(autoincrement=True, primary_key=True, index=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+    zone_id: Mapped[int] = mapped_column(ForeignKey("zone.id"), index=True)
+    is_active: Mapped[bool] = mapped_column(default=True, nullable=False)
+    timesheet: Mapped[JSON] = mapped_column(JSON, nullable=True)
+    locked_by: Mapped[str] = mapped_column(default=None, nullable=True)
+    legacy_id: Mapped[uuid.UUID] = mapped_column(UUID(as_uuid=True), nullable=True)
+
+    @declared_attr
+    def zone(cls) -> Mapped["Zone"]:
+        return relationship(back_populates="schedules")
+
+
+class ScheduleSync(CustomSyncBase, ScheduleMixin):
+    pass
+
+
+class Schedule(CustomBase, ScheduleMixin):
+    pass