add missing endpoints

kontor-api/src/apis/base.py

@@ -2,31 +2,31 @@
 add router for different parts (like comics, tysc, media)
 """
 
-from fastapi import APIRouter
+from fastapi import APIRouter, Depends
+from src.apis.version1.admin import token
+from src.apis.version1.comics import artist, comic, issue
+from src.apis.version1.media import mediaactor, mediaactorfile, mediafile
+from src.apis.version1.tysc import card, cardset, fieldposition, player, rooster, sport, team, vendor
+from src.core.security import get_current_user_from_token
 
-from src.apis.version1 import (
-    comic,
-    mediaactor,
-    mediafile,
-    mediaactorfile,
-    sport,
-    player,
-    team,
-    fieldposition,
-    vendor,
-    admin,
-    user,
-)
+from src.apis.version1.user import profile
+from src.apis.version1.bookshelf import article
 
 api_router = APIRouter(prefix="/api")
-api_router.include_router(comic.router, prefix="/comics", tags=["comics"])
-api_router.include_router(mediafile.router, prefix="/media", tags=["media"])
-api_router.include_router(mediaactor.router, prefix="/media", tags=["media"])
-api_router.include_router(mediaactorfile.router, prefix="/media", tags=["media"])
-api_router.include_router(sport.router, prefix="/tysc", tags=["tysc"])
-api_router.include_router(player.router, prefix="/tysc", tags=["tysc"])
-api_router.include_router(team.router, prefix="/tysc", tags=["tysc"])
-api_router.include_router(fieldposition.router, prefix="/tysc", tags=["tysc"])
-api_router.include_router(vendor.router, prefix="/tysc", tags=["tysc"])
-api_router.include_router(admin.router, prefix="/login", tags=["login"])
-api_router.include_router(user.router, prefix="/user", tags=["user"])
+api_router.include_router(comic.router, prefix="/comics", tags=["comics"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(artist.router, prefix="/comics", tags=["comics"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(issue.router, prefix="/comics", tags=["comics"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(mediafile.router, prefix="/media", tags=["media"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(mediaactor.router, prefix="/media", tags=["media"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(mediaactorfile.router, prefix="/media", tags=["media"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(sport.router, prefix="/tysc", tags=["tysc"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(player.router, prefix="/tysc", tags=["tysc"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(team.router, prefix="/tysc", tags=["tysc"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(fieldposition.router, prefix="/tysc", tags=["tysc"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(rooster.router, prefix="/tysc", tags=["tysc"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(vendor.router, prefix="/tysc", tags=["tysc"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(cardset.router, prefix="/tysc", tags=["tysc"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(card.router, prefix="/tysc", tags=["tysc"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(article.router, prefix="/bookshelf", tags=["bookshelf"], dependencies=[Depends(get_current_user_from_token)])
+api_router.include_router(token.router, prefix="/login", tags=["login"])
+api_router.include_router(profile.router, prefix="/user", tags=["user"], dependencies=[Depends(get_current_user_from_token)])

kontor-api/src/apis/version1/admin/login.py

@@ -26,7 +26,7 @@ class LoginRequest(BaseModel):
 )
 def login(request: LoginRequest) -> Token:
     logger.info(f"login with {request.email}")
-    user = authenticate_user_by_email(request.email, request.password)
+    user = authenticate_user_by_email(str(request.email), str(request.password))
     scopes = ["admin", "read"]
     if not user:
         raise HTTPException(

kontor-api/src/apis/version1/bookshelf/article.py

@@ -0,0 +1,20 @@
+from typing import List
+
+from fastapi import APIRouter
+
+from src.db.models.bookshelf import Article
+from src.db.session import SessionDep
+from src.schema.bookshelf.article import ArticleResponse, to_response
+
+
+router = APIRouter()
+
+
+@router.get("/articles", response_model=List[ArticleResponse])
+def get_all_artists(db: SessionDep) -> List[ArticleResponse]:
+    results: List[ArticleResponse] = []
+    articles = db.query(Article).all()
+    for article in articles:
+        response = to_response(article)
+        results.append(response)
+    return results

kontor-api/src/apis/version1/comics/artist.py

@@ -0,0 +1,43 @@
+from typing import List
+
+from fastapi import APIRouter, HTTPException, status
+
+from src.db.models.comic import Artist
+from src.db.repository.comics.artist import get_artist_details
+from src.db.session import SessionDep
+from src.schema.comics.artist import ArtistCreation, ArtistResponse
+from src.schema.comics.artist_details import ArtistDetailResponse
+
+
+router = APIRouter()
+
+
+@router.get("/artists", response_model=List[ArtistResponse])
+def get_all_artists(db: SessionDep) -> List[ArtistResponse]:
+    results: List[ArtistResponse] = []
+    artists = db.query(Artist).all()
+    for artist in artists:
+        results.append(ArtistResponse(id=artist.id, name=str(artist.name)))
+    return results
+
+
+@router.get("/artists/{artist_id}", response_model=ArtistDetailResponse)
+def get_artist(artist_id: str, db: SessionDep) -> ArtistDetailResponse:
+    artist = db.get(Artist, artist_id)
+    if artist is None:
+        raise HTTPException(status_code=404, detail="Artist could not be found")
+    response: ArtistDetailResponse = get_artist_details(artist)
+    return response
+
+
+@router.post("/artists", status_code=status.HTTP_201_CREATED)
+def add_artist(db: SessionDep, artist_creation: ArtistCreation) -> ArtistResponse:
+    artist: Artist = Artist()
+    setattr(artist, "name", artist_creation.name)
+    try:
+        db.add(artist)
+        db.commit()
+    except:
+        raise HTTPException(status_code=409, detail="Artist already added")
+    response = ArtistResponse(id=artist.id, name=str(artist.name))
+    return response

kontor-api/src/apis/version1/comics/comic.py

@@ -1,9 +1,9 @@
 from typing import List
 
-from fastapi import APIRouter, HTTPException, status
+from fastapi import APIRouter, HTTPException
 
 from src.core.log_conf import logger
-from src.db.models.comic import Artist, Comic, Issue, Publisher
+from src.db.models.comic import Comic, Publisher
 from src.db.repository.comics.artist import get_artist_details
 from src.db.repository.comics.comic import (
     get_comic_details,
@@ -13,11 +13,8 @@ from src.db.repository.comics.comic import (
 )
 from src.db.repository.comics.publisher import get_publisher_details
 from src.db.session import SessionDep
-from src.schema.comics.artist import ArtistCreation, ArtistResponse
-from src.schema.comics.artist_details import ArtistDetailResponse
 from src.schema.comics.comic import ComicResponse
 from src.schema.comics.comic_details import ComicDetailsResponse
-from src.schema.comics.issue_details import IssueDetailsResponse
 from src.schema.comics.publisher import PublisherResponse
 from src.schema.comics.publisher_details import PublisherDetailsResponse
 
@@ -25,7 +22,7 @@ router = APIRouter()
 
 
 @router.get("/comics")
-def get_all_comics(db: SessionDep) -> List[ComicResponse]: # type: ignore
+def get_all_comics(db: SessionDep) -> List[ComicResponse]:
     results: List[ComicResponse] = []
     comics = list_comics(db)
     for comic in comics:
@@ -35,7 +32,7 @@ def get_all_comics(db: SessionDep) -> List[ComicResponse]: # type: ignore
 
 
 @router.get("/comics/{comic_id}", response_model=ComicDetailsResponse)
-def get_comic(comic_id: str, db: SessionDep) -> ComicDetailsResponse: # type: ignore
+def get_comic(comic_id: str, db: SessionDep) -> ComicDetailsResponse:
     comic = db.get(Comic, comic_id)
     if comic is None:
         raise HTTPException(status_code=404, detail="Comic could not be found")
@@ -45,39 +42,10 @@ def get_comic(comic_id: str, db: SessionDep) -> ComicDetailsResponse: # type: ig
     return response
 
 
-@router.get("/artists", response_model=List[ArtistResponse])
-def get_all_artists(db: SessionDep) -> List[ArtistResponse]: # type: ignore
-    results: List[ArtistResponse] = []
-    artists = db.query(Artist).all()
-    for artist in artists:
-        results.append(ArtistResponse(id=artist.id, name=str(artist.name))) # type: ignore
-    return results
-
-
-@router.get("/artists/{artist_id}", response_model=ArtistDetailResponse)
-def get_artist(artist_id: str, db: SessionDep) -> ArtistDetailResponse: # type: ignore
-    artist = db.get(Artist, artist_id)
-    if artist is None:
-        raise HTTPException(status_code=404, detail="Artist could not be found")
-    response: ArtistDetailResponse = get_artist_details(artist)
-    return response
-
-
-@router.post("/artists", status_code=status.HTTP_201_CREATED)
-def add_artist(db: SessionDep, artist_creation: ArtistCreation) -> ArtistResponse: # type: ignore
-    artist: Artist = Artist()
-    setattr(artist, "name", artist_creation.name)
-    try:
-        db.add(artist)
-        db.commit()
-    except:
-        raise HTTPException(status_code=409, detail="Artist already added")
-    response = ArtistResponse(id=artist.id, name=str(artist.name))
-    return response
 
 
 @router.get("/publishers", response_model=List[PublisherResponse])
-def get_all_publishers(db: SessionDep) -> List[PublisherResponse]: # type: ignore
+def get_all_publishers(db: SessionDep) -> List[PublisherResponse]:
     results: List[PublisherResponse] = []
     publishers = db.query(Publisher).all()
     for publisher in publishers:
@@ -86,18 +54,10 @@ def get_all_publishers(db: SessionDep) -> List[PublisherResponse]: # type: ignor
 
 
 @router.get("/publishers/{publisher_id}", response_model=PublisherDetailsResponse)
-def get_publisher(publisher_id: str, db: SessionDep) -> PublisherDetailsResponse: # type: ignore
+def get_publisher(publisher_id: str, db: SessionDep) -> PublisherDetailsResponse:
     publisher = db.get(Publisher, publisher_id)
     if publisher is None:
         raise HTTPException(status_code=404, detail="Publisher could not be found")
     response: PublisherDetailsResponse = get_publisher_details(publisher)
     return response
 
-
-@router.get("/issues", response_model=List[IssueDetailsResponse])
-def get_issues(db: SessionDep) -> List[IssueDetailsResponse]: # type: ignore
-    results: List[IssueDetailsResponse] = []
-    issues = db.query(Issue).all()
-    for issue in issues:
-        results.append(get_issue_details(issue))
-    return results

kontor-api/src/apis/version1/comics/issue.py

@@ -0,0 +1,19 @@
+from typing import List
+
+from fastapi import APIRouter
+
+from src.db.models.comic import Issue
+from src.db.repository.comics.comic import get_issue_details
+from src.db.session import SessionDep
+from src.schema.comics.issue_details import IssueDetailsResponse
+
+
+router = APIRouter()
+
+@router.get("/issues", response_model=List[IssueDetailsResponse])
+def get_issues(db: SessionDep) -> List[IssueDetailsResponse]:
+    results: List[IssueDetailsResponse] = []
+    issues = db.query(Issue).all()
+    for issue in issues:
+        results.append(get_issue_details(issue))
+    return results

kontor-api/src/apis/version1/media/mediafile.py

@@ -1,9 +1,8 @@
 from typing import List
 
-from fastapi import APIRouter, status, HTTPException, Depends
-from sqlalchemy import select, Sequence
+from fastapi import APIRouter, status, HTTPException
+from sqlalchemy import select
 from src.core.log_conf import logger
-from src.core.security import UserDep, get_current_user_from_token
 from src.db.repository.media import (
     create_new_mediaactorfile,
     create_new_mediafile,
@@ -34,11 +33,7 @@ def update_titles(db: SessionDep) -> list[MediaFileResponse]:
     return results
 
 
-@router.get(
-    "/files",
-    response_model=list[MediaFileResponse],
-    dependencies=[Depends(get_current_user_from_token)],
-)
+@router.get("/files", response_model=list[MediaFileResponse])
 def get_all_files(
     db: SessionDep, review: bool = False, download: bool = False
 ) -> List[MediaFileResponse]:
@@ -59,11 +54,7 @@ def get_all_files(
     return results
 
 
-@router.get(
-    "/files/{file_id}",
-    response_model=MediaFileResponse,
-    dependencies=[Depends(get_current_user_from_token)],
-)
+@router.get("/files/{file_id}", response_model=MediaFileResponse)
 def get_file(file_id: str, db: SessionDep) -> MediaFileResponse:
     """
     Get MediaFile with given id or return HTTPException.

kontor-api/src/apis/version1/tysc/card.py

@@ -0,0 +1,19 @@
+from typing import List
+
+from fastapi import APIRouter
+
+from src.db.models.tysc import Card
+from src.db.session import SessionDep
+from src.schema.tysc.card import CardResponse, to_response
+
+
+router = APIRouter()
+
+@router.get("/cards")
+def get_all_players(db: SessionDep) -> List[CardResponse]:
+    results: List[CardResponse] = []
+    cards = db.query(Card).all()
+    for card in cards:
+        response = to_response(card)
+        results.append(response)
+    return results

kontor-api/src/apis/version1/tysc/cardset.py

@@ -0,0 +1,19 @@
+from typing import List
+
+from fastapi import APIRouter
+
+from src.db.models.tysc import CardSet
+from src.db.session import SessionDep
+from src.schema.tysc.cardset import CardSetResponse, to_response
+
+
+router = APIRouter()
+
+@router.get("/cardsets")
+def get_all_players(db: SessionDep) -> List[CardSetResponse]:
+    results: List[CardSetResponse] = []
+    cardsets = db.query(CardSet).all()
+    for cardset in cardsets:
+        response = to_response(cardset)
+        results.append(response)
+    return results

kontor-api/src/apis/version1/tysc/rooster.py

@@ -0,0 +1,19 @@
+from typing import List
+
+from fastapi import APIRouter
+
+from src.db.models.tysc import Rooster
+from src.db.session import SessionDep
+from src.schema.tysc.rooster import RoosterResponse, to_response
+
+
+router = APIRouter()
+
+@router.get("/roosters")
+def get_all_sports(db: SessionDep) -> List[RoosterResponse]:
+    results: list[RoosterResponse] = []
+    roosters = db.query(Rooster).all()
+    for rooster in roosters:
+        response = to_response(rooster)
+        results.append(response)
+    return results