Added draftdata and keepers

app/db_engine.py

@@ -1820,6 +1820,97 @@ class DraftList(BaseModel):
     player = ForeignKeyField(Player)
 
 
+class Keeper(BaseModel):
+    season = IntegerField()
+    team = ForeignKeyField(Team)
+    player = ForeignKeyField(Player)
+
+
+class Injury(BaseModel):
+    season = IntegerField()
+    player = ForeignKeyField(Player)
+    total_games = IntegerField()
+    start_week = IntegerField()
+    start_game = IntegerField()
+    end_week = IntegerField()
+    end_game = IntegerField()
+    is_active = BooleanField(default=True)
+
+
+class StratGame(BaseModel):
+    season = IntegerField()
+    week = IntegerField()
+    game_num = IntegerField()
+    season_type = CharField(default='regular')
+    away_team = ForeignKeyField(Team)
+    home_team = ForeignKeyField(Team)
+    away_score = IntegerField(null=True)
+    home_score = IntegerField(null=True)
+
+
+class StratPlay(BaseModel):
+    game = ForeignKeyField(StratGame)
+    play_num = IntegerField()
+    batter = ForeignKeyField(Player)
+    pitcher = ForeignKeyField(Player)
+    on_base_code = IntegerField()
+    inning_half = CharField()
+    inning_num = IntegerField()
+    batting_order = IntegerField()
+    starting_outs = IntegerField()
+    away_score = IntegerField()
+    home_score = IntegerField()
+    batter_pos = CharField()
+
+    # These <base>_final fields track the base this runner advances to post-play (None) if out
+    on_first = ForeignKeyField(Player, null=True)
+    on_first_final = IntegerField(null=True)
+    on_second = ForeignKeyField(Player, null=True)
+    on_second_final = IntegerField(null=True)
+    on_third = ForeignKeyField(Player, null=True)
+    on_third_final = IntegerField(null=True)
+    batter_final = IntegerField(null=True)
+
+    pa = IntegerField(default=0)
+    ab = IntegerField(default=0)
+    run = IntegerField(default=0)
+    hit = IntegerField(default=0)
+    rbi = IntegerField(default=0)
+    double = IntegerField(default=0)
+    triple = IntegerField(default=0)
+    homerun = IntegerField(default=0)
+    bb = IntegerField(default=0)
+    so = IntegerField(default=0)
+    hbp = IntegerField(default=0)
+    sac = IntegerField(default=0)
+    ibb = IntegerField(default=0)
+    gidp = IntegerField(default=0)
+    bphr = IntegerField(default=0)
+    bpfo = IntegerField(default=0)
+    bp1b = IntegerField(default=0)
+    bplo = IntegerField(default=0)
+    sb = IntegerField(default=0)
+    cs = IntegerField(default=0)
+    outs = IntegerField(default=0)
+    wpa = FloatField(default=0)
+
+    # These <position> fields are only required if the play is an x-check or baserunning play
+    catcher = ForeignKeyField(Player, null=True)
+    defender = ForeignKeyField(Player, null=True)
+    runner = ForeignKeyField(Player, null=True)
+
+    check_pos = CharField(null=True)
+    error = IntegerField(default=0)
+    wild_pitch = IntegerField(default=0)
+    passed_ball = IntegerField(default=0)
+    pick_off = IntegerField(default=0)
+    balk = IntegerField(default=0)
+    is_go_ahead = BooleanField(default=False)
+    is_tied = BooleanField(default=False)
+    is_new_inning = BooleanField(default=False)
+
+
+
 # class Streak(BaseModel):
 #     player = ForeignKeyField(Player)
 #     streak_type = CharField()
@@ -1844,6 +1935,6 @@ class DraftList(BaseModel):
 
 db.create_tables([
     Current, Division, Manager, Team, Result, Player, Schedule, Transaction, BattingStat, PitchingStat, Standings,
-    BattingCareer, PitchingCareer, FieldingCareer, Manager, Award, DiceRoll, DraftList
+    BattingCareer, PitchingCareer, FieldingCareer, Manager, Award, DiceRoll, DraftList, Keeper
 ])
 db.close()

app/main.py

@@ -7,7 +7,7 @@ from fastapi import Depends, FastAPI, Request
 # from fastapi.openapi.utils import get_openapi
 
 from .routers_v3 import current, players, results, schedules, standings, teams, transactions, battingstats, \
-    pitchingstats, fieldingstats, draftpicks, draftlist, managers, awards
+    pitchingstats, fieldingstats, draftpicks, draftlist, managers, awards, draftdata, keepers
 
 date = f'{datetime.datetime.now().year}-{datetime.datetime.now().month}-{datetime.datetime.now().day}'
 log_level = logging.INFO if os.environ.get('LOG_LEVEL') == 'INFO' else 'WARN'
@@ -36,6 +36,8 @@ app.include_router(draftpicks.router)
 app.include_router(draftlist.router)
 app.include_router(managers.router)
 app.include_router(awards.router)
+app.include_router(draftdata.router)
+app.include_router(keepers.router)
 
 
 # @app.get("/docs", include_in_schema=False)

app/routers_v3/draftdata.py

@@ -0,0 +1,73 @@
+import datetime
+
+from fastapi import APIRouter, Depends, HTTPException
+from typing import Optional
+import logging
+import pydantic
+
+from ..db_engine import db, DraftData, model_to_dict
+from ..dependencies import oauth2_scheme, valid_token
+
+router = APIRouter(
+    prefix='/api/v3/draftdata',
+    tags=['draftdata']
+)
+
+
+class DraftDataModel(pydantic.BaseModel):
+    currentpick: int
+    timer: bool
+    pick_deadline: datetime.datetime
+    result_channel_id = int
+    ping_channel_id = int
+    pick_minutes = int
+
+
+@router.get('')
+async def get_draftdata():
+    draft_data = DraftData.get_or_none()
+
+    if draft_data is not None:
+        r_data = model_to_dict(draft_data)
+        db.close()
+        return r_data
+
+    raise HTTPException(status_code=404, detail=f'No draft data found')
+
+
+@router.patch('/{data_id}')
+async def patch_draftdata(
+        data_id: int, currentpick: Optional[int] = None, timer: Optional[bool] = None,
+        pick_deadline: Optional[datetime.datetime] = None, result_channel: Optional[int] = None,
+        ping_channel: Optional[int] = None, pick_minutes: Optional[int] = None, token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'patch_draftdata - Bad Token: {token}')
+        raise HTTPException(status_code=401, detail='Unauthorized')
+
+    draft_data = DraftData.get_or_none(DraftData.id == data_id)
+    if draft_data is None:
+        db.close()
+        raise HTTPException(status_code=404, detail=f'No draft data found')
+
+    if currentpick is not None:
+        draft_data.currentpick = currentpick
+    if timer is not None:
+        draft_data.timer = timer
+    if pick_deadline is not None:
+        draft_data.pick_deadline = pick_deadline
+    if result_channel is not None:
+        draft_data.result_channel = result_channel
+    if ping_channel is not None:
+        draft_data.ping_channel = ping_channel
+    if pick_minutes is not None:
+        draft_data.pick_minutes = pick_minutes
+
+    saved = draft_data.save()
+    r_data = model_to_dict(draft_data)
+    db.close()
+
+    if saved == 1:
+        return r_data
+    else:
+        raise HTTPException(status_code=500, detail='Updating draft data failed')
+

app/routers_v3/keepers.py

@@ -0,0 +1,113 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, Response
+from typing import List, Optional
+import logging
+import pydantic
+
+from ..db_engine import db, Keeper, Player, model_to_dict, chunked, fn
+from ..dependencies import oauth2_scheme, valid_token, LOG_DATA
+
+logging.basicConfig(filename=LOG_DATA['filename'], format=LOG_DATA['format'], level=LOG_DATA['log_level'])
+
+router = APIRouter(
+    prefix='/api/v3/keepers',
+    tags=['keepers']
+)
+
+
+class KeeperModel(pydantic.BaseModel):
+    season: int
+    team_id: int
+    player_id: int
+
+
+class KeeperList(pydantic.BaseModel):
+    count: Optional[int] = None
+    keepers: List[KeeperModel]
+
+
+@router.get('')
+async def get_keepers(
+        season: list = Query(default=None), team_id: list = Query(default=None), player_id: list = Query(default=None),
+        short_output: bool = False):
+    all_keepers = Keeper.select()
+
+    if season is not None:
+        all_keepers = all_keepers.where(Keeper.season << season)
+    if team_id is not None:
+        all_keepers = all_keepers.where(Keeper.team_id << team_id)
+    if player_id is not None:
+        all_keepers = all_keepers.where(Keeper.player_id << player_id)
+
+    return_keepers = {
+        'count': all_keepers.count(),
+        'keepers': [model_to_dict(x, recurse=not short_output) for x in all_keepers]
+    }
+    db.close()
+    return return_keepers
+
+
+@router.patch('/{keeper_id}')
+async def patch_keeper(
+        keeper_id: int, season: Optional[int] = None, team_id: Optional[int] = None, player_id: Optional[int] = None,
+        token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'patch_keeper - Bad Token: {token}')
+        raise HTTPException(status_code=401, detail='Unauthorized')
+
+    this_keeper = Keeper.get_or_none(Keeper.id == keeper_id)
+    if not this_keeper:
+        raise HTTPException(status_code=404, detail=f'Keeper ID {keeper_id} not found')
+
+    if season is not None:
+        this_keeper.season = season
+    if player_id is not None:
+        this_keeper.player_id = player_id
+    if team_id is not None:
+        this_keeper.team_id = team_id
+
+    if this_keeper.save():
+        r_keeper = model_to_dict(this_keeper)
+        db.close()
+        return r_keeper
+    else:
+        db.close()
+        raise HTTPException(status_code=500, detail=f'Unable to patch keeper {keeper_id}')
+
+
+@router.post('')
+async def post_keepers(k_list: KeeperList, token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'post_keepers - Bad Token: {token}')
+        raise HTTPException(status_code=401, detail='Unauthorized')
+
+    new_keepers = []
+    for keeper in k_list.keepers:
+        new_keepers.append(keeper.dict())
+
+    with db.atomic():
+        for batch in chunked(new_keepers, 14):
+            Keeper.insert_many(batch).on_conflict_replace().execute()
+    db.close()
+
+    return f'Inserted {len(new_keepers)} keepers'
+
+
+@router.delete('/{keeper_id}')
+async def delete_keeper(keeper_id: int, token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'delete_keeper - Bad Token: {token}')
+        raise HTTPException(status_code=401, detail='Unauthorized')
+
+    this_keeper = Keeper.get_or_none(Keeper.id == keeper_id)
+    if not this_keeper:
+        raise HTTPException(status_code=404, detail=f'Keeper ID {keeper_id} not found')
+
+    count = this_keeper.delete_instance()
+    db.close()
+
+    if count == 1:
+        return f'Keeper ID {keeper_id} has been deleted'
+    else:
+        raise HTTPException(status_code=500, detail=f'Keeper ID {keeper_id} could not be deleted')
+
+