Added /managers

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
+    pitchingstats, fieldingstats, draftpicks, draftlist, managers
 
 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'
@@ -34,6 +34,7 @@ app.include_router(pitchingstats.router)
 app.include_router(fieldingstats.router)
 app.include_router(draftpicks.router)
 app.include_router(draftlist.router)
+app.include_router(managers.router)
 
 
 # @app.get("/docs", include_in_schema=False)

app/routers_v3/managers.py

@@ -0,0 +1,143 @@
+from fastapi import APIRouter, Depends, HTTPException, Query
+from typing import List, Optional
+import logging
+import pydantic
+
+from ..db_engine import db, Manager, Team, Current, model_to_dict, chunked, fn
+from ..dependencies import oauth2_scheme, valid_token
+
+router = APIRouter(
+    prefix='/api/v3/managers',
+    tags=['managers']
+)
+
+
+class ManagerModel(pydantic.BaseModel):
+    name: str
+    image: Optional[str] = None
+    headline: Optional[str] = None
+    bio: Optional[str] = None
+
+
+@router.get('')
+async def get_managers(
+        name: list = Query(default=None), active: Optional[bool] = None, short_output: Optional[bool] = False):
+    if active is not None:
+        current = Current.latest()
+        t_query = Team.select().where(
+            Team.season == current.season & ~(Team.abbrev.endswith('IL')) & ~(Team.abbrev.endswith('MiL'))
+        )
+        a_mgr = []
+        i_mgr = []
+
+        for x in t_query:
+            if x.manager1 is not None:
+                a_mgr.append(x.manager1)
+            if x.manager2 is not None:
+                a_mgr.append(x.manager2)
+
+        if active:
+            final_mgrs = [model_to_dict(y, recurse=not short_output) for y in a_mgr]
+        else:
+            for z in Manager.select():
+                if z not in a_mgr:
+                    i_mgr.append(z)
+            final_mgrs = [model_to_dict(y, recurse=not short_output) for y in i_mgr]
+
+        return_managers = {
+            'count': len(final_mgrs),
+            'managers': final_mgrs
+        }
+
+    else:
+        all_managers = Manager.select()
+        if name is not None:
+            name_list = [x.lower() for x in name]
+            all_managers = all_managers.where(fn.Lower(Manager.name) << name_list)
+
+        return_managers = {
+            'count': all_managers.count(),
+            'managers': [model_to_dict(x, recurse=not short_output) for x in all_managers]
+        }
+
+    db.close()
+    return return_managers
+
+
+@router.get('/{manager_id}')
+async def get_one_manager(manager_id: int, short_output: Optional[bool] = False):
+    this_manager = Manager.get_or_none(Manager.id == manager_id)
+    if this_manager is not None:
+        r_manager = model_to_dict(this_manager, recurse=not short_output)
+        db.close()
+        return r_manager
+    else:
+        raise HTTPException(status_code=404, detail=f'Manager {manager_id} not found')
+
+
+@router.patch('/{manager_id}')
+async def patch_manager(
+        manager_id: int, name: Optional[str] = None, image: Optional[str] = None, headline: Optional[str] = None,
+        bio: Optional[str] = None, token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'patch_manager - Bad Token: {token}')
+        raise HTTPException(status_code=401, detail='Unauthorized')
+
+    this_manager = Manager.get_or_none(Manager.id == manager_id)
+    if this_manager is None:
+        db.close()
+        raise HTTPException(status_code=404, detail=f'Manager ID {manager_id} not found')
+
+    if name is not None:
+        this_manager.name = name
+    if image is not None:
+        this_manager.image = image
+    if headline is not None:
+        this_manager.headline = headline
+    if bio is not None:
+        this_manager.bio = bio
+
+    if this_manager.save() == 1:
+        r_manager = model_to_dict(this_manager)
+        db.close()
+        return r_manager
+    else:
+        db.close()
+        raise HTTPException(status_code=500, detail=f'Unable to patch manager {this_manager}')
+
+
+@router.post('')
+async def post_manager(new_manager: ManagerModel, token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'post_manager - Bad Token: {token}')
+        raise HTTPException(status_code=401, detail='Unauthorized')
+
+    this_manager = Manager(**new_manager.dict())
+
+    if this_manager.save():
+        r_manager = model_to_dict(this_manager)
+        db.close()
+        return r_manager
+    else:
+        db.close()
+        raise HTTPException(status_code=500, detail=f'Unable to post manager {this_manager.name}')
+
+
+@router.delete('/{manager_id}')
+async def delete_manager(manager_id: int, token: str = Depends(oauth2_scheme)):
+    if not valid_token(token):
+        logging.warning(f'delete_manager - Bad Token: {token}')
+        raise HTTPException(status_code=401, detail='Unauthorized')
+
+    this_manager = Manager.get_or_none(Manager.id == manager_id)
+    if this_manager is None:
+        db.close()
+        raise HTTPException(status_code=404, detail=f'Manager ID {manager_id} not found')
+
+    count = this_manager.delete_instance()
+    db.close()
+
+    if count == 1:
+        return f'Manager {manager_id} has been deleted'
+    else:
+        raise HTTPException(status_code=500, detail=f'Manager {manager_id} could not be deleted')