Merge pull request #2 from calcorum/gauntlets

Gauntlets

db_engine.py

@@ -458,7 +458,26 @@ class Notification(BaseModel):
     ack = BooleanField(default=False)
 
 
-db.create_tables(
+class GauntletReward(BaseModel):
-    [Roster, BattingStat, PitchingStat, Result, Award, Paperdex, Reward, GameRewards, Notification]
+    name = CharField()
-)
+    gauntlet = ForeignKeyField(Event)
+    reward = ForeignKeyField(GameRewards)
+    win_num = IntegerField()
+    loss_max = IntegerField(default=1)
+
+
+class GauntletRun(BaseModel):
+    team = ForeignKeyField(Team)
+    gauntlet = ForeignKeyField(Event)
+    wins = IntegerField(default=0)
+    losses = IntegerField(default=0)
+    gsheet = CharField(null=True)
+    created = DateTimeField(default=int(datetime.timestamp(datetime.now())*1000))
+    ended = DateTimeField(default=0)
+
+
+db.create_tables([
+    Roster, BattingStat, PitchingStat, Result, Award, Paperdex, Reward, GameRewards, Notification, GauntletReward,
+    GauntletRun
+])
 db.close()

main.py

@@ -229,7 +229,7 @@ async def v1_teams_get(
         cv_max: Optional[int] = None, ps_shiny_min: Optional[int] = None, ps_shiny_max: Optional[int] = None,
         ranking_min: Optional[int] = None, ranking_max: Optional[int] = None, has_guide: Optional[bool] = None,
         sname: Optional[str] = None, lname: Optional[str] = None, is_ai: Optional[bool] = None,
-        limit: Optional[int] = None, csv: Optional[bool] = False):
+        event_id: Optional[int] = None, limit: Optional[int] = None, csv: Optional[bool] = False):
     """
     Param: season: int
     Param: team_abbrev: string
@@ -292,6 +292,9 @@ async def v1_teams_get(
     if is_ai is not None:
         all_teams = all_teams.where(Team.is_ai)
 
+    if event_id is not None:
+        all_teams = all_teams.where(Team.event_id == event_id)
+
     if limit is not None:
         all_teams = all_teams.limit(limit)
 
@@ -1295,7 +1298,7 @@ async def v1_players_get(
 
 @app.get('/api/v1/players/random')
 async def v1_players_get_random(
-        min_cost: Optional[int] = None, max_cost: Optional[int] = None, in_packs: Optional[bool] = True,
+        min_cost: Optional[int] = None, max_cost: Optional[int] = None, in_packs: Optional[bool] = None,
         min_rarity: Optional[int] = None, max_rarity: Optional[int] = None, limit: Optional[int] = None,
         pos_include: Optional[str] = None, pos_exclude: Optional[str] = None, franchise: Optional[str] = None,
         mlbclub: Optional[str] = None, cardset_id: list = Query(default=None), pos_inc: list = Query(default=None),
@@ -1337,16 +1340,24 @@ async def v1_players_get_random(
             (Player.pos_1 << p_list) | (Player.pos_2 << p_list) | (Player.pos_3 << p_list) | (Player.pos_4 << p_list) |
             (Player.pos_5 << p_list) | (Player.pos_6 << p_list) | (Player.pos_7 << p_list) | (Player.pos_8 << p_list)
         )
-    if pos_exc is not None:
+    # if pos_exc is not None:
-        p_list = [x.upper() for x in pos_exc]
+    #     p_list = [x.upper() for x in pos_exc]
-        all_players = all_players.where(
+    #     logging.info(f'starting query: {all_players}\n\np_list: {p_list}\n\n')
-            (Player.pos_1.not_in(p_list)) | (Player.pos_2.not_in(p_list)) | (Player.pos_3.not_in(p_list)) |
+    #     all_players = all_players.where(
-            (Player.pos_4.not_in(p_list)) | (Player.pos_5.not_in(p_list)) | (Player.pos_6.not_in(p_list)) |
+    #         Player.pos_1.not_in(p_list) & Player.pos_2.not_in(p_list) & Player.pos_3.not_in(p_list) &
-            (Player.pos_7.not_in(p_list)) | (Player.pos_8.not_in(p_list))
+    #         Player.pos_4.not_in(p_list) & Player.pos_5.not_in(p_list) & Player.pos_6.not_in(p_list) &
-        )
+    #         Player.pos_7.not_in(p_list) & Player.pos_8.not_in(p_list)
+    #     )
+    #     logging.info(f'post pos query: {all_players}')
 
     if pos_exclude is not None and pos_exc is None:
         final_players = [x for x in all_players if pos_exclude not in x.get_all_pos()]
+    elif pos_exc is not None and pos_exclude is None:
+        final_players = []
+        p_list = [x.upper() for x in pos_exc]
+        for x in all_players:
+            if not set(p_list).intersection(x.get_all_pos()):
+                final_players.append(x)
     else:
         final_players = all_players
 
@@ -4498,3 +4509,282 @@ async def v1_gamerewards_delete(gamereward_id, token: str = Depends(oauth2_schem
         raise HTTPException(status_code=200, detail=f'Game Reward {gamereward_id} has been deleted')
     else:
         raise HTTPException(status_code=500, detail=f'Game Reward {gamereward_id} was not deleted')
+
+
+"""
+GAUNTLET REWARD ENDPOINTS
+"""
+
+
+class GauntletRewardModel(pydantic.BaseModel):
+    name: str
+    gauntlet_id: Optional[int] = 0
+    reward_id: Optional[int] = 0
+    win_num: Optional[int] = 0
+    loss_max: Optional[int] = 1
+
+
+class GauntletRewardList(pydantic.BaseModel):
+    rewards: List[GauntletRewardModel]
+
+
+@app.get('/api/v1/gauntletrewards')
+async def v1_gauntletreward_get(
+        name: Optional[str] = None, gauntlet_id: Optional[int] = None, reward_id: list = Query(default=None),
+        win_num: Optional[int] = None, loss_max: Optional[int] = None):
+    all_rewards = GauntletReward.select()
+
+    if name is not None:
+        all_rewards = all_rewards.where(GauntletReward.name == name)
+    if gauntlet_id is not None:
+        all_rewards = all_rewards.where(GauntletReward.gauntlet_id == gauntlet_id)
+    if reward_id is not None:
+        all_rewards = all_rewards.where(GauntletReward.reward_id << reward_id)
+    if win_num is not None:
+        all_rewards = all_rewards.where(GauntletReward.win_num == win_num)
+    if loss_max is not None:
+        all_rewards = all_rewards.where(GauntletReward.loss_max == loss_max)
+
+    all_rewards = all_rewards.order_by(-GauntletReward.loss_max, GauntletReward.win_num)
+
+    return_val = {'count': all_rewards.count(), 'rewards': []}
+    for x in all_rewards:
+        return_val['rewards'].append(model_to_dict(x))
+
+    db.close()
+    return return_val
+
+
+@app.get('/api/v1/gauntletrewards/{gauntletreward_id}')
+async def v1_gauntletreward_get_one(gauntletreward_id):
+    try:
+        this_reward = GauntletReward.get_by_id(gauntletreward_id)
+    except Exception:
+        db.close()
+        raise HTTPException(status_code=404, detail=f'No gauntlet reward found with id {gauntletreward_id}')
+
+    return_val = model_to_dict(this_reward)
+    db.close()
+    return return_val
+
+
+@app.patch('/api/v1/gauntletrewards/{gauntletreward_id}')
+async def v1_gauntletreward_patch(
+        gauntletreward_id, name: Optional[str] = None, gauntlet_id: Optional[int] = None,
+        reward_id: Optional[int] = None, win_num: Optional[int] = None, loss_max: Optional[int] = None,
+        token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'Bad Token: {token}')
+        db.close()
+        raise HTTPException(
+            status_code=401,
+            detail='You are not authorized to patch gauntlet rewards. This event has been logged.'
+        )
+
+    this_reward = GauntletReward.get_or_none(GauntletReward.id == gauntletreward_id)
+    if this_reward is None:
+        db.close()
+        raise KeyError(f'Gauntlet Reward ID {gauntletreward_id} not found')
+
+    if gauntlet_id is not None:
+        this_reward.gauntlet_id = gauntlet_id
+    if reward_id is not None:
+        this_reward.reward_id = reward_id
+    if win_num is not None:
+        this_reward.win_num = win_num
+    if loss_max is not None:
+        this_reward.loss_max = loss_max
+    if name is not None:
+        this_reward.name = name
+
+    if this_reward.save():
+        r_curr = model_to_dict(this_reward)
+        db.close()
+        return r_curr
+    else:
+        db.close()
+        raise DatabaseError(f'Unable to patch gauntlet reward {gauntletreward_id}')
+
+
+@app.post('/api/v1/gauntletrewards')
+async def v1_gauntletreward_post(gauntletreward: GauntletRewardList, token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'Bad Token: {token}')
+        db.close()
+        raise HTTPException(
+            status_code=401,
+            detail='You are not authorized to post gauntlets. This event has been logged.'
+        )
+
+    all_rewards = []
+    for x in gauntletreward.rewards:
+        all_rewards.append(x.dict())
+
+    with db.atomic():
+        for batch in chunked(all_rewards, 15):
+            GauntletReward.insert_many(batch).on_conflict_replace().execute()
+    db.close()
+
+    return f'Inserted {len(all_rewards)} gauntlet rewards'
+
+
+@app.delete('/api/v1/gauntletrewards/{gauntletreward_id}')
+async def v1_gauntletreward_delete(gauntletreward_id):
+    if GauntletReward.delete_by_id(gauntletreward_id) == 1:
+        return f'Deleted gauntlet reward ID {gauntletreward_id}'
+
+    raise DatabaseError(f'Unable to delete gauntlet run {gauntletreward_id}')
+
+
+"""
+GAUNTLET ENDPOINTS
+"""
+
+
+class GauntletRunModel(pydantic.BaseModel):
+    team_id: int
+    gauntlet_id: int
+    wins: Optional[int] = 0
+    losses: Optional[int] = 0
+    gsheet: Optional[str] = None
+    created: Optional[int] = int(datetime.timestamp(datetime.now())*1000)
+    ended: Optional[int] = 0
+
+
+@app.get('/api/v1/gauntletruns')
+async def v1_gauntletrun_get(
+        team_id: list = Query(default=None), wins: Optional[int] = None, wins_min: Optional[int] = None,
+        wins_max: Optional[int] = None, losses: Optional[int] = None, losses_min: Optional[int] = None,
+        losses_max: Optional[int] = None, gsheet: Optional[str] = None, created_after: Optional[int] = None,
+        created_before: Optional[int] = None, ended_after: Optional[int] = None, ended_before: Optional[int] = None,
+        is_active: Optional[bool] = None, gauntlet_id: list = Query(default=None), season: list = Query(default=None)):
+    all_gauntlets = GauntletRun.select()
+
+    if team_id is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.team_id << team_id)
+    if wins is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.wins == wins)
+    if wins_min is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.wins >= wins_min)
+    if wins_max is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.wins <= wins_max)
+    if losses is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.losses == losses)
+    if losses_min is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.losses >= losses_min)
+    if losses_max is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.losses <= losses_max)
+    if gsheet is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.gsheet == gsheet)
+    if created_after is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.created >= created_after)
+    if created_before is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.created <= created_before)
+    if ended_after is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.ended >= ended_after)
+    if ended_before is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.ended <= ended_before)
+    if is_active is not None:
+        if is_active is True:
+            all_gauntlets = all_gauntlets.where(GauntletRun.ended == 0)
+        else:
+            all_gauntlets = all_gauntlets.where(GauntletRun.ended != 0)
+    if gauntlet_id is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.gauntlet_id << gauntlet_id)
+    if season is not None:
+        all_gauntlets = all_gauntlets.where(GauntletRun.team.season << season)
+
+    return_val = {'count': all_gauntlets.count(), 'runs': []}
+    for x in all_gauntlets:
+        return_val['runs'].append(model_to_dict(x))
+
+    db.close()
+    return return_val
+
+
+@app.get('/api/v1/gauntletruns/{gauntletrun_id}')
+async def v1_gauntletrun_get_one(gauntletrun_id):
+    try:
+        this_gauntlet = GauntletRun.get_by_id(gauntletrun_id)
+    except Exception:
+        db.close()
+        raise HTTPException(status_code=404, detail=f'No gauntlet found with id {gauntletrun_id}')
+
+    return_val = model_to_dict(this_gauntlet)
+    db.close()
+    return return_val
+
+
+@app.patch('/api/v1/gauntletruns/{gauntletrun_id}')
+async def v1_gauntletrun_patch(
+        gauntletrun_id, team_id: Optional[int] = None, wins: Optional[int] = None, losses: Optional[int] = None,
+        gsheet: Optional[str] = None, created: Optional[bool] = None, ended: Optional[bool] = None,
+        token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'Bad Token: {token}')
+        db.close()
+        raise HTTPException(
+            status_code=401,
+            detail='You are not authorized to patch gauntlet runs. This event has been logged.'
+        )
+
+    this_run = GauntletRun.get_or_none(GauntletRun.id == gauntletrun_id)
+    if this_run is None:
+        db.close()
+        raise KeyError(f'Gauntlet Run ID {gauntletrun_id} not found')
+
+    if team_id is not None:
+        this_run.team_id = team_id
+    if wins is not None:
+        this_run.wins = wins
+    if losses is not None:
+        this_run.losses = losses
+    if gsheet is not None:
+        this_run.gsheet = gsheet
+    if created is not None:
+        if created is True:
+            this_run.created = int(datetime.timestamp(datetime.now())*1000)
+        else:
+            this_run.created = None
+    if ended is not None:
+        if ended is True:
+            this_run.ended = int(datetime.timestamp(datetime.now())*1000)
+        else:
+            this_run.ended = 0
+
+    if this_run.save():
+        r_curr = model_to_dict(this_run)
+        db.close()
+        return r_curr
+    else:
+        db.close()
+        raise DatabaseError(f'Unable to patch gauntlet run {gauntletrun_id}')
+
+
+@app.post('/api/v1/gauntletruns')
+async def v1_gauntletrun_post(gauntletrun: GauntletRunModel, token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'Bad Token: {token}')
+        db.close()
+        raise HTTPException(
+            status_code=401,
+            detail='You are not authorized to post gauntlets. This event has been logged.'
+        )
+
+    this_run = GauntletRun(**gauntletrun.dict())
+
+    if this_run.save():
+        r_run = model_to_dict(this_run)
+        db.close()
+        return r_run
+    else:
+        db.close()
+        raise DatabaseError(f'Unable to post gauntlet run')
+
+
+@app.delete('/api/v1/gauntletruns/{gauntletrun_id}')
+async def v1_gauntletrun_delete(gauntletrun_id):
+    if GauntletRun.delete_by_id(gauntletrun_id) == 1:
+        return f'Deleted gauntlet run ID {gauntletrun_id}'
+
+    raise DatabaseError(f'Unable to delete gauntlet run {gauntletrun_id}')