mirror of
https://github.com/nihilvux/bancho.py.git
synced 2025-10-01 05:44:42 -07:00
138 lines
4.4 KiB
Python
138 lines
4.4 KiB
Python
from __future__ import annotations
|
|
|
|
from typing import TypedDict
|
|
from typing import cast
|
|
|
|
from sqlalchemy import Column
|
|
from sqlalchemy import Index
|
|
from sqlalchemy import Integer
|
|
from sqlalchemy import delete
|
|
from sqlalchemy import insert
|
|
from sqlalchemy import select
|
|
|
|
import app.state.services
|
|
from app.repositories import Base
|
|
|
|
|
|
class TourneyPoolMapsTable(Base):
|
|
__tablename__ = "tourney_pool_maps"
|
|
|
|
map_id = Column("map_id", Integer, nullable=False, primary_key=True)
|
|
pool_id = Column("pool_id", Integer, nullable=False, primary_key=True)
|
|
mods = Column("mods", Integer, nullable=False)
|
|
slot = Column("slot", Integer, nullable=False)
|
|
|
|
__table_args__ = (
|
|
Index("tourney_pool_maps_mods_slot_index", mods, slot),
|
|
Index("tourney_pool_maps_tourney_pools_id_fk", pool_id),
|
|
)
|
|
|
|
|
|
READ_PARAMS = (
|
|
TourneyPoolMapsTable.map_id,
|
|
TourneyPoolMapsTable.pool_id,
|
|
TourneyPoolMapsTable.mods,
|
|
TourneyPoolMapsTable.slot,
|
|
)
|
|
|
|
|
|
class TourneyPoolMap(TypedDict):
|
|
map_id: int
|
|
pool_id: int
|
|
mods: int
|
|
slot: int
|
|
|
|
|
|
async def create(map_id: int, pool_id: int, mods: int, slot: int) -> TourneyPoolMap:
|
|
"""Create a new map pool entry in the database."""
|
|
insert_stmt = insert(TourneyPoolMapsTable).values(
|
|
map_id=map_id,
|
|
pool_id=pool_id,
|
|
mods=mods,
|
|
slot=slot,
|
|
)
|
|
await app.state.services.database.execute(insert_stmt)
|
|
|
|
select_stmt = (
|
|
select(*READ_PARAMS)
|
|
.where(TourneyPoolMapsTable.map_id == map_id)
|
|
.where(TourneyPoolMapsTable.pool_id == pool_id)
|
|
)
|
|
tourney_pool_map = await app.state.services.database.fetch_one(select_stmt)
|
|
assert tourney_pool_map is not None
|
|
return cast(TourneyPoolMap, tourney_pool_map)
|
|
|
|
|
|
async def fetch_many(
|
|
pool_id: int | None = None,
|
|
mods: int | None = None,
|
|
slot: int | None = None,
|
|
page: int | None = 1,
|
|
page_size: int | None = 50,
|
|
) -> list[TourneyPoolMap]:
|
|
"""Fetch a list of map pool entries from the database."""
|
|
select_stmt = select(*READ_PARAMS)
|
|
if pool_id is not None:
|
|
select_stmt = select_stmt.where(TourneyPoolMapsTable.pool_id == pool_id)
|
|
if mods is not None:
|
|
select_stmt = select_stmt.where(TourneyPoolMapsTable.mods == mods)
|
|
if slot is not None:
|
|
select_stmt = select_stmt.where(TourneyPoolMapsTable.slot == slot)
|
|
if page and page_size:
|
|
select_stmt = select_stmt.limit(page_size).offset((page - 1) * page_size)
|
|
|
|
tourney_pool_maps = await app.state.services.database.fetch_all(select_stmt)
|
|
return cast(list[TourneyPoolMap], tourney_pool_maps)
|
|
|
|
|
|
async def fetch_by_pool_and_pick(
|
|
pool_id: int,
|
|
mods: int,
|
|
slot: int,
|
|
) -> TourneyPoolMap | None:
|
|
"""Fetch a map pool entry by pool and pick from the database."""
|
|
select_stmt = (
|
|
select(*READ_PARAMS)
|
|
.where(TourneyPoolMapsTable.pool_id == pool_id)
|
|
.where(TourneyPoolMapsTable.mods == mods)
|
|
.where(TourneyPoolMapsTable.slot == slot)
|
|
)
|
|
tourney_pool_map = await app.state.services.database.fetch_one(select_stmt)
|
|
return cast(TourneyPoolMap | None, tourney_pool_map)
|
|
|
|
|
|
async def delete_map_from_pool(pool_id: int, map_id: int) -> TourneyPoolMap | None:
|
|
"""Delete a map pool entry from a given tourney pool from the database."""
|
|
select_stmt = (
|
|
select(*READ_PARAMS)
|
|
.where(TourneyPoolMapsTable.pool_id == pool_id)
|
|
.where(TourneyPoolMapsTable.map_id == map_id)
|
|
)
|
|
|
|
tourney_pool_map = await app.state.services.database.fetch_one(select_stmt)
|
|
if tourney_pool_map is None:
|
|
return None
|
|
|
|
delete_stmt = (
|
|
delete(TourneyPoolMapsTable)
|
|
.where(TourneyPoolMapsTable.pool_id == pool_id)
|
|
.where(TourneyPoolMapsTable.map_id == map_id)
|
|
)
|
|
|
|
await app.state.services.database.execute(delete_stmt)
|
|
return cast(TourneyPoolMap, tourney_pool_map)
|
|
|
|
|
|
async def delete_all_in_pool(pool_id: int) -> list[TourneyPoolMap]:
|
|
"""Delete all map pool entries from a given tourney pool from the database."""
|
|
select_stmt = select(*READ_PARAMS).where(TourneyPoolMapsTable.pool_id == pool_id)
|
|
tourney_pool_maps = await app.state.services.database.fetch_all(select_stmt)
|
|
if not tourney_pool_maps:
|
|
return []
|
|
|
|
delete_stmt = delete(TourneyPoolMapsTable).where(
|
|
TourneyPoolMapsTable.pool_id == pool_id,
|
|
)
|
|
await app.state.services.database.execute(delete_stmt)
|
|
return cast(list[TourneyPoolMap], tourney_pool_maps)
|