Adds play pins and apps.

Author: lexicalunit

poetry.lock

@@ -166,6 +166,7 @@ python-dateutil = "^2.8.2"
 python-dotenv = "^1.0.1"
 pytz = ">=2024.1"
 pyyaml = "^6.0.1"
+redis = "^5.2.1"
 requests = "^2.31.0"
 sqlalchemy = "^2.0.29"
 sqlalchemy-utils = "^0.41.2"

pyproject.toml

@@ -10,9 +10,7 @@
 from spellbot.models import Channel, ChannelDict, GuildAward, GuildAwardDict
 from spellbot.operations import (
     safe_fetch_text_channel,
-    safe_get_partial_message,
     safe_send_channel,
-    safe_update_embed,
     safe_update_embed_origin,
 )
 from spellbot.services import GamesService
@@ -475,40 +473,41 @@ async def move_user(
             ephemeral=True,
         )
 
-    async def set_points(self, game_id: int, player_xid: int, points: int) -> None:
-        found = await self.services.games.select(game_id)
-        if not found:
-            await safe_send_channel(
-                self.interaction,
-                "There is no game with that ID.",
-                ephemeral=True,
-            )
-            return
-
-        if not await self.services.games.players_included(player_xid):
-            await safe_send_channel(
-                self.interaction,
-                f"User <@{player_xid}> did not play in game SB{found.get('id')}.",
-                ephemeral=True,
-            )
-            return
-
-        await self.services.games.add_points(player_xid, points)
-        await self.services.games.confirm_points(player_xid)
-
-        for post in found.get("posts", []):
-            guild_xid = post["guild_xid"]
-            channel_xid = post["channel_xid"]
-            channel = await safe_fetch_text_channel(self.bot, guild_xid, channel_xid)
-            if channel:
-                message_xid = post["message_xid"]
-                message = safe_get_partial_message(channel, guild_xid, message_xid)
-                if message:
-                    embed = await self.services.games.to_embed(self.guild)
-                    await safe_update_embed(message, embed=embed)
-
-        await safe_send_channel(
-            self.interaction,
-            f"Points for <@{player_xid}> for game SB{game_id} set to {points}.",
-            ephemeral=True,
-        )
+    # TODO: Refactor how confirmation/points/ELO works.
+    # async def set_points(self, game_id: int, player_xid: int, points: int) -> None:
+    #     found = await self.services.games.select(game_id)
+    #     if not found:
+    #         await safe_send_channel(
+    #             self.interaction,
+    #             "There is no game with that ID.",
+    #             ephemeral=True,
+    #         )
+    #         return
+    #
+    #     if not await self.services.games.players_included(player_xid):
+    #         await safe_send_channel(
+    #             self.interaction,
+    #             f"User <@{player_xid}> did not play in game SB{found.get('id')}.",
+    #             ephemeral=True,
+    #         )
+    #         return
+    #
+    #     await self.services.games.add_points(player_xid, points)
+    #     await self.services.games.confirm_points(player_xid)
+    #
+    #     for post in found.get("posts", []):
+    #         guild_xid = post["guild_xid"]
+    #         channel_xid = post["channel_xid"]
+    #         channel = await safe_fetch_text_channel(self.bot, guild_xid, channel_xid)
+    #         if channel:
+    #             message_xid = post["message_xid"]
+    #             message = safe_get_partial_message(channel, guild_xid, message_xid)
+    #             if message:
+    #                 embed = await self.services.games.to_embed(self.guild)
+    #                 await safe_update_embed(message, embed=embed)
+    #
+    #     await safe_send_channel(
+    #         self.interaction,
+    #         f"Points for <@{player_xid}> for game SB{game_id} set to {points}.",
+    #         ephemeral=True,
+    #     )

src/spellbot/actions/admin_action.py

@@ -0,0 +1,24 @@
+"""
+Adds play pins.
+
+Revision ID: 2bf551e10a79
+Revises: a59f2a831a84
+Create Date: 2025-01-27 19:34:51.499841
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "2bf551e10a79"
+down_revision = "a59f2a831a84"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.add_column("plays", sa.Column("pin", sa.String(length=6), nullable=True))
+
+
+def downgrade() -> None:
+    op.drop_column("plays", "pin")

src/spellbot/migrations/versions/2bf551e10a79_adds_play_pins.py

@@ -0,0 +1,44 @@
+"""
+Adds api tokens.
+
+Revision ID: a59f2a831a84
+Revises: 6f5fb731f4c1
+Create Date: 2025-01-27 19:23:45.776047
+"""
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "a59f2a831a84"
+down_revision = "6f5fb731f4c1"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "token",
+        sa.Column("id", sa.Integer(), autoincrement=True, nullable=False),
+        sa.Column(
+            "created_at",
+            sa.DateTime(),
+            server_default=sa.text("(now() at time zone 'utc')"),
+            nullable=False,
+        ),
+        sa.Column(
+            "updated_at",
+            sa.DateTime(),
+            server_default=sa.text("(now() at time zone 'utc')"),
+            nullable=False,
+        ),
+        sa.Column("deleted_at", sa.DateTime(), nullable=True),
+        sa.Column("key", sa.String(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_token_key"), "token", ["key"], unique=False)
+
+
+def downgrade() -> None:
+    op.drop_index(op.f("ix_token_key"), table_name="token")
+    op.drop_table("token")

src/spellbot/migrations/versions/a59f2a831a84_adds_api_tokens.py

@@ -26,6 +26,7 @@ def import_models() -> None:  # pragma: no cover
 from .post import Post, PostDict  # noqa: E402
 from .queue import Queue, QueueDict  # noqa: E402
 from .record import Record, RecordDict  # noqa: E402
+from .token import Token, TokenDict  # noqa: E402
 from .user import User, UserDict  # noqa: E402
 from .verify import Verify, VerifyDict  # noqa: E402
 from .watch import Watch, WatchDict  # noqa: E402
@@ -53,6 +54,8 @@ def import_models() -> None:  # pragma: no cover
     "QueueDict",
     "Record",
     "RecordDict",
+    "Token",
+    "TokenDict",
     "User",
     "UserAward",
     "UserAwardDict",

src/spellbot/models/__init__.py

@@ -1,16 +1,21 @@
 from __future__ import annotations
 
+import secrets
 from datetime import datetime
 from typing import TYPE_CHECKING, TypedDict, cast
 
-from sqlalchemy import BigInteger, Column, DateTime, ForeignKey, Integer
+from sqlalchemy import BigInteger, Column, DateTime, ForeignKey, Integer, String
 
 from . import Base, now
 
 if TYPE_CHECKING:
     from . import Game, User  # noqa: F401
 
 
+def generate_pin() -> str:
+    return "".join(secrets.choice("0123456789") for i in range(6))
+
+
 class PlayDict(TypedDict):
     created_at: datetime
     updated_at: datetime
@@ -19,6 +24,7 @@ class PlayDict(TypedDict):
     og_guild_xid: int
     points: int | None
     confirmed_at: datetime
+    pin: str
 
 
 class Play(Base):
@@ -75,6 +81,12 @@ class Play(Base):
         default=None,
         doc="UTC timestamp when this play was confirmed",
     )
+    pin = Column(
+        String(6),
+        nullable=True,
+        default=generate_pin,
+        doc="A generated PIN for users to identify this game",
+    )
 
     def to_dict(self) -> PlayDict:
         return {
@@ -85,4 +97,5 @@ def to_dict(self) -> PlayDict:
             "og_guild_xid": self.og_guild_xid,
             "points": self.points,
             "confirmed_at": self.confirmed_at,
+            "pin": self.pin,
         }

src/spellbot/models/play.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TypedDict
+
+from sqlalchemy import Column, DateTime, Integer, String
+
+from . import Base, now
+
+
+class TokenDict(TypedDict):
+    id: int
+    created_at: datetime
+    updated_at: datetime
+    deleted_at: datetime | None
+    key: str
+
+
+class Token(Base):
+    """Token keys for access to the SpellBot API."""
+
+    __tablename__ = "token"
+
+    id = Column(
+        Integer,
+        autoincrement=True,
+        nullable=False,
+        primary_key=True,
+        doc="A pk for this token",
+    )
+    created_at = Column(
+        DateTime,
+        nullable=False,
+        default=datetime.utcnow,
+        server_default=now,
+        doc="UTC timestamp when this key was first created",
+    )
+    updated_at = Column(
+        DateTime,
+        nullable=False,
+        default=datetime.utcnow,
+        server_default=now,
+        onupdate=datetime.utcnow,
+        doc="UTC timestamp when this key was last updated",
+    )
+    deleted_at = Column(
+        DateTime,
+        nullable=True,
+        index=True,
+        doc="UTC timestamp when this key was deleted",
+    )
+    key = Column(
+        String,
+        nullable=False,
+        index=True,
+        doc="The API token key",
+    )
+
+    def to_dict(self) -> TokenDict:
+        return {
+            "id": self.id,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "deleted_at": self.deleted_at,
+            "key": self.key,
+        }

src/spellbot/models/token.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from .apps import AppsService
 from .awards import AwardsService, NewAward
 from .channels import ChannelsService
 from .games import GamesService
@@ -20,9 +21,11 @@ def __init__(self) -> None:
         self.users = UsersService()
         self.verifies = VerifiesService()
         self.watches = WatchesService()
+        self.apps = AppsService()
 
 
 __all__ = [
+    "AppsService",
     "AwardsService",
     "ChannelsService",
     "GamesService",

src/spellbot/services/__init__.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from asgiref.sync import sync_to_async
+from ddtrace import tracer
+
+from spellbot.database import DatabaseSession
+from spellbot.models import Token
+
+
+class AppsService:
+    @sync_to_async()
+    @tracer.wrap()
+    def verify_token(self, key: str) -> bool:
+        return bool(DatabaseSession.query(Token).filter(Token.key == key).count())