refactor kontor-api to use SQLAlchemy 2.0 features for mapping fields

(cherry picked from commit e57abdbef7e13e3880738cd639225df5db0c37be)

kontor-api/src/apis/base.py

@@ -1,6 +1,6 @@
 from fastapi import APIRouter
 
-from src.apis.version1 import comic, mediaactor, mediafile, mediaactorfile, tysc, admin
+from src.apis.version1 import comic, mediaactor, mediafile, mediaactorfile, tysc, admin, user
 
 api_router =  APIRouter(prefix="/api")
 api_router.include_router(comic.router, prefix="/comics", tags=["comics"])
@@ -9,3 +9,4 @@ api_router.include_router(mediaactor.router, prefix="/media", tags=["media"])
 api_router.include_router(mediaactorfile.router, prefix="/media", tags=["media"])
 api_router.include_router(tysc.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"])

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

@@ -25,7 +25,7 @@ router = APIRouter()
 
 
 @router.get("/comics")
-def get_all_comics(db: SessionDep) -> List[ComicResponse]:
+def get_all_comics(db: SessionDep) -> List[ComicResponse]: # type: ignore
     results: List[ComicResponse] = []
     comics = list_comics(db)
     for comic in comics:
@@ -35,7 +35,7 @@ def get_all_comics(db: SessionDep) -> List[ComicResponse]:
 
 
 @router.get("/comics/{comic_id}", response_model=ComicDetailsResponse)
-def get_comic(comic_id: str, db: SessionDep) -> ComicDetailsResponse:
+def get_comic(comic_id: str, db: SessionDep) -> ComicDetailsResponse: # type: ignore
     comic = db.get(Comic, comic_id)
     if comic is None:
         raise HTTPException(status_code=404, detail="Comic could not be found")
@@ -46,7 +46,7 @@ def get_comic(comic_id: str, db: SessionDep) -> ComicDetailsResponse:
 
 
 @router.get("/artists", response_model=List[ArtistResponse])
-def get_all_artists(db: SessionDep) -> List[ArtistResponse]:
+def get_all_artists(db: SessionDep) -> List[ArtistResponse]: # type: ignore
     results: List[ArtistResponse] = []
     artists = db.query(Artist).all()
     for artist in artists:
@@ -55,7 +55,7 @@ def get_all_artists(db: SessionDep) -> List[ArtistResponse]:
 
 
 @router.get("/artists/{artist_id}", response_model=ArtistDetailResponse)
-def get_artist(artist_id: str, db: SessionDep) -> 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")
@@ -64,7 +64,7 @@ def get_artist(artist_id: str, db: SessionDep) -> ArtistDetailResponse:
 
 
 @router.post("/artists", status_code=status.HTTP_201_CREATED)
-def add_artist(db: SessionDep, artist_creation: ArtistCreation) -> ArtistResponse:
+def add_artist(db: SessionDep, artist_creation: ArtistCreation) -> ArtistResponse: # type: ignore
     artist: Artist = Artist()
     setattr(artist, "name", artist_creation.name)
     try:
@@ -77,7 +77,7 @@ def add_artist(db: SessionDep, artist_creation: ArtistCreation) -> ArtistRespons
 
 
 @router.get("/publishers", response_model=List[PublisherResponse])
-def get_all_publishers(db: SessionDep) -> List[PublisherResponse]:
+def get_all_publishers(db: SessionDep) -> List[PublisherResponse]: # type: ignore
     results: List[PublisherResponse] = []
     publishers = db.query(Publisher).all()
     for publisher in publishers:
@@ -86,7 +86,7 @@ def get_all_publishers(db: SessionDep) -> List[PublisherResponse]:
 
 
 @router.get("/publishers/{publisher_id}", response_model=PublisherDetailsResponse)
-def get_publisher(publisher_id: str, db: SessionDep) -> PublisherDetailsResponse:
+def get_publisher(publisher_id: str, db: SessionDep) -> PublisherDetailsResponse: # type: ignore
     publisher = db.get(Publisher, publisher_id)
     if publisher is None:
         raise HTTPException(status_code=404, detail="Publisher could not be found")
@@ -95,7 +95,7 @@ def get_publisher(publisher_id: str, db: SessionDep) -> PublisherDetailsResponse
 
 
 @router.get("/issues", response_model=List[IssueDetailsResponse])
-def get_issues(db: SessionDep) -> List[IssueDetailsResponse]:
+def get_issues(db: SessionDep) -> List[IssueDetailsResponse]: # type: ignore
     results: List[IssueDetailsResponse] = []
     issues = db.query(Issue).all()
     for issue in issues:

kontor-api/src/apis/version1/mediaactor.py

@@ -1,9 +1,9 @@
 from fastapi import APIRouter, status, HTTPException
 from sqlalchemy import select
 from src.core.log_conf import logger
-from src.db.repository.media import create_new_mediaactor, delete_mediaactor
+from src.db.repository.media import create_new_mediaactor, delete_mediaactor, get_actor_details
 from src.db.session import SessionDep
-from src.schema.media.actor import Actor, MediaActorResponse, get_actor_details
+from src.schema.media.actor import MediaActorModel, MediaActorResponse
 from src.db.models.media import MediaActor
 
 router = APIRouter()
@@ -32,13 +32,10 @@ def delete_actor(actor_id: str, db: SessionDep): # type: ignore
     if not media_actor:
         raise HTTPException(status_code=404, detail="MediaActor could not be found")
     logger.info(f"delete MediaActor: {actor_id}")
-    actor_files = media_actor.media_actor_files
-    logger.info(f"MediaActorFiles links {len(actor_files)}")
-    if len(actor_files) == 0:
-        delete_mediaactor(db, media_actor.id)
+    delete_mediaactor(db, media_actor.id)
 
 @router.post("/actors", status_code=status.HTTP_201_CREATED)
-def add_actor(new_actor: Actor, db: SessionDep) -> MediaActorResponse: # type: ignore
+def add_actor(new_actor: MediaActorModel, db: SessionDep) -> MediaActorResponse: # type: ignore
     logger.info(f"add actor {new_actor.url}")
     try:
         mediaActor: MediaActor = create_new_mediaactor(new_actor, db)

kontor-api/src/apis/version1/mediaactorfile.py

@@ -1,18 +1,19 @@
+from typing import List
 from fastapi import APIRouter, status, HTTPException
 from sqlalchemy import select
 from src.db.models.media import MediaActorFile
-from src.db.repository.media import delete_mediaactorfile
+from src.db.repository.media import delete_mediaactorfile, get_actorfile_details
 from src.db.session import SessionDep
-from src.schema.media.actorfile import MediaActorFileResponse, get_actorfile_details
+from src.schema.media.actorfile import MediaActorFileResponse
 
 router = APIRouter()
 
-@router.get("/actorfiles", response_model=list[MediaActorFileResponse])
-def get_all_actorfiles(db: SessionDep) -> list[MediaActorFileResponse]: # type: ignore
-    results: list[MediaActorFileResponse] = []
+@router.get("/actorfiles", response_model=List[MediaActorFileResponse])
+def get_all_actorfiles(db: SessionDep) -> List[MediaActorFileResponse]: # type: ignore
+    results: List[MediaActorFileResponse] = []
     actorfiles = db.scalars(select(MediaActorFile)).all()
-    for mediaactorfile in actorfiles:
-        response = MediaActorFileResponse(id=mediaactorfile.id, actor_id=str(mediaactorfile.media_actor_id), file_id=str(mediaactorfile.media_file_id))
+    for media_actorfile in actorfiles:
+        response = get_actorfile_details(media_actorfile)
         results.append(response)
     return results
 
@@ -30,4 +31,3 @@ def delete_actorfile(actorfile_id: str, db: SessionDep): # type: ignore
     if not media_actorfile:
         raise HTTPException(status_code=404, detail="MediaActor could not be found")
     delete_mediaactorfile(db, media_actorfile.id)
-

kontor-api/src/apis/version1/user.py

@@ -0,0 +1,47 @@
+from typing import List
+from fastapi import APIRouter, HTTPException, status
+from sqlalchemy import select
+from src.core.log_conf import logger
+
+from src.db.models.admin import Profile
+from src.db.repository.user import create_new_profile, get_profile_details
+from src.db.session import SessionDep
+from src.schema.user.profile import ProfileResponse, ProfileModel
+
+
+router = APIRouter()
+
+@router.get("/profiles", response_model=List[ProfileResponse])
+def get_all_profiles(db: SessionDep) -> List[ProfileResponse]: # type: ignore
+    results: List[ProfileResponse] = []
+    profiles = db.scalars(select(Profile)).all()
+    for profile in profiles:
+        response = get_profile_details(profile)
+        results.append(response)
+    return results
+
+@router.get("/profiles/{profile_id}", response_model=ProfileResponse)
+def get_profile(profile_id: str, db: SessionDep) -> ProfileResponse: # type: ignore
+    profile = db.get(Profile, profile_id)
+    if not profile:
+        raise HTTPException(status_code=404, detail="MediaActor could not be found")
+    response = get_profile_details(profile)
+    return response
+
+@router.delete("/profiles/{profile_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_profile(profile_id: str, db: SessionDep): # type: ignore
+    profile = db.get(Profile, profile_id)
+    if not profile:
+        raise HTTPException(status_code=404, detail="Profile could not be found")
+    logger.info(f"delete Profile: {profile_id}")
+    delete_profile(profile_id=profile_id, db=db)
+
+@router.post("/profiles", status_code=status.HTTP_201_CREATED)
+def add_profile(new_profile: ProfileModel, db: SessionDep) -> ProfileResponse: # type: ignore
+    logger.info(f"add profile {new_profile.user_name}")
+    try:
+        profile: Profile = create_new_profile(new_profile, db)
+    except:
+        raise HTTPException(status_code=409, detail="Profile duplicate")
+    response = get_profile_details(profile)
+    return response