add kontor-blacksheep and kontor-piccolo as blueprints for new app

.gitignore

@@ -6,9 +6,3 @@ node_modules/
 .editorconfig
 db-password.txt
 couchdb-password.txt
-kontor-robyn/kontor.db
-kontor-robyn.bak
-kontor-robyn.bak2
-kontor-data/.gradle
-kontor-data/build/
-/kontor-api/kontor-api.code-workspace

deploy-kontor.sh

@@ -1,12 +0,0 @@
-# Posted by barth, modified by community. See post 'Timeline' for change history
-# Retrieved 2026-08-19, License - CC BY-SA 4.0
-NEXUS_URL=https://nexus.thpeetz.de
-MAVEN_REPO=maven-snapshots
-GROUP_ID=de.thpeetz
-ARTIFACT_ID=kontor-spring
-VERSION=0.4.0
-FILE_EXTENSION=jar
-
-download_url=$(curl -X GET "${NEXUS_URL}/service/rest/v1/search/assets?repository=${MAVEN_REPO}&maven.groupId=${GROUP_ID}&maven.artifactId=${ARTIFACT_ID}&maven.baseVersion=${VERSION}&maven.extension=${FILE_EXTENSION}" -H  "accept: application/json"  | jq -rc '.items | .[].downloadUrl' | sort | tail -n 1)
-wget $download_url
-

kontor-api/Containerfile

@@ -14,6 +14,7 @@ ENV PATH="/root/.local/bin:${PATH}"
 WORKDIR /app
 
 COPY ./pyproject.toml .
+
 RUN uv sync
 
 # ------------------------------- Production Stage ------------------------------ ##

kontor-api/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kontor-api"
-version = "0.4.0"
+version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -24,21 +24,9 @@ dependencies = [
     "psycopg2-binary>=2.9.10",
     "pytest-cov>=6.1.1",
     "databases[sqlite]>=0.9.0",
+    "pydantic[email]>=2.11.3",
     "jinja2>=3.1.6",
     "asyncpg>=0.30.0",
     "bcrypt>=4.3.0",
     "fastapi-jwt-auth>=0.5.0",
-    "msgspec[toml,yaml]>=0.21.1",
-    "kontor-model",
 ]
-
-[[tool.uv.index]]
-name = "nexus"
-url = "https://nexus.thpeetz.de/repository/pypi-group/simple"
-publish-url = "https://nexus.thpeetz.de/repository/pypi-internal/"
-default = true
-
-
-[[tool.uv.index]]
-name = "nexus-proxy"
-url = "https://nexus.thpeetz.de/repository/pypi-proxy/simple"

kontor-api/src/apis/base.py

@@ -18,7 +18,6 @@ from src.apis.version1.comics import (
 from src.apis.version1.media import (
     actor,
     file,
-    lofi,
     mediaactorfile,
     mediavideo,
     mediaarticle,
@@ -105,12 +104,6 @@ api_router.include_router(
     tags=["media"],
     dependencies=[Depends(get_current_user_from_token)],
 )
-api_router.include_router(
-    lofi.router,
-    prefix="/media",
-    tags=["media"],
-    dependencies=[Depends(get_current_user_from_token)],
-)
 api_router.include_router(
     mediaarticle.router,
     prefix="/media",

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

@@ -9,8 +9,8 @@ from src.core.security import (
     authenticate_user_by_username,
     create_access_token,
 )
-from kontor_model.schema.admin.login import LoginRequest
-from kontor_model.schema.admin.token import Token
+from src.schema.admin.login import LoginRequest
+from src.schema.admin.token import Token
 from src.webapps.auth.forms import LoginForm
 
 login_router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.admin import MailAccount
+from src.db.models.admin import MailAccount
 from src.db.session import SessionDep
-from kontor_model.schema.admin.mailaccount import MailAccountResponse, to_response
+from src.schema.admin.mailaccount import MailAccountResponse, to_response
 
 router = APIRouter()
 

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter
 
-from kontor_model.db.models.bookshelf import Article
+from src.db.models.bookshelf import Article
 from src.db.session import SessionDep
-from kontor_model.schema.bookshelf.article import ArticleResponse, to_response
+from src.schema.bookshelf.article import ArticleResponse, to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter
 
-from kontor_model.db.models.bookshelf import ArticleAuthor
+from src.db.models.bookshelf import ArticleAuthor
 from src.db.session import SessionDep
-from kontor_model.schema.bookshelf.articleauthor import ArticleAuthorResponse, to_response
+from src.schema.bookshelf.articleauthor import ArticleAuthorResponse, to_response
 
 router = APIRouter()
 

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.bookshelf import Author
+from src.db.models.bookshelf import Author
 from src.db.session import SessionDep
-from kontor_model.schema.bookshelf.author import AuthorResponse, to_response
+from src.schema.bookshelf.author import AuthorResponse, to_response
 
 router = APIRouter()
 

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter
 
-from kontor_model.db.models.bookshelf import Book
+from src.db.models.bookshelf import Book
 from src.db.session import SessionDep
-from kontor_model.schema.bookshelf.book import BookResponse, to_response
+from src.schema.bookshelf.book import BookResponse, to_response
 
 router = APIRouter()
 

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter
 
-from kontor_model.db.models.bookshelf import BookAuthor
+from src.db.models.bookshelf import BookAuthor
 from src.db.session import SessionDep
-from kontor_model.schema.bookshelf.bookauthor import BookAuthorResponse, to_response
+from src.schema.bookshelf.bookauthor import BookAuthorResponse, to_response
 
 router = APIRouter()
 

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter
 
-from kontor_model.db.models.bookshelf import BookshelfPublisher
+from src.db.models.bookshelf import BookshelfPublisher
 from src.db.session import SessionDep
-from kontor_model.schema.bookshelf.publisher import PublisherResponse, to_response
+from src.schema.bookshelf.publisher import PublisherResponse, to_response
 
 router = APIRouter()
 

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

@@ -2,11 +2,11 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException, status
 
-from kontor_model.db.models.comic import Artist
-from kontor_model.db.repository.comics.artist import get_artist_details
+from src.db.models.comic import Artist
+from src.db.repository.comics.artist import get_artist_details
 from src.db.session import SessionDep
-from kontor_model.schema.comics.artist import ArtistCreation, ArtistResponse, artist_to_response
-from kontor_model.schema.comics.artist_details import ArtistDetailResponse
+from src.schema.comics.artist import ArtistCreation, ArtistResponse, artist_to_response
+from src.schema.comics.artist_details import ArtistDetailResponse
 
 
 router = APIRouter()

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

@@ -3,13 +3,13 @@ from typing import List
 from fastapi import APIRouter, HTTPException
 
 from src.core.log_conf import logger
-from kontor_model.db.models.comic import Comic
-from kontor_model.db.repository.comics.comic import (
+from src.db.models.comic import Comic
+from src.db.repository.comics.comic import (
     get_comic_details,
 )
 from src.db.session import SessionDep
-from kontor_model.schema.comics.comic import ComicResponse, comic_to_response
-from kontor_model.schema.comics.comic_details import ComicDetailsResponse
+from src.schema.comics.comic import ComicResponse, comic_to_response
+from src.schema.comics.comic_details import ComicDetailsResponse
 
 router = APIRouter()
 

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.comic import ComicWork
+from src.db.models.comic import ComicWork
 from src.db.session import SessionDep
-from kontor_model.schema.comics.comicwork import ComicWorkResponse, comicwork_to_response
+from src.schema.comics.comicwork import ComicWorkResponse, comicwork_to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.comic import Issue
+from src.db.models.comic import Issue
 from src.db.session import SessionDep
-from kontor_model.schema.comics.issue import IssueResponse, issue_to_response
+from src.schema.comics.issue import IssueResponse, issue_to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.comic import IssueWork
+from src.db.models.comic import IssueWork
 from src.db.session import SessionDep
-from kontor_model.schema.comics.issuework import IssueWorkResponse, issuework_to_response
+from src.schema.comics.issuework import IssueWorkResponse, issuework_to_response
 
 
 router = APIRouter()

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

@@ -2,11 +2,11 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.comic import Publisher
-from kontor_model.db.repository.comics.publisher import get_publisher_details
+from src.db.models.comic import Publisher
+from src.db.repository.comics.publisher import get_publisher_details
 from src.db.session import SessionDep
-from kontor_model.schema.comics.publisher import PublisherResponse, publisher_to_response
-from kontor_model.schema.comics.publisher_details import PublisherDetailsResponse
+from src.schema.comics.publisher import PublisherResponse, publisher_to_response
+from src.schema.comics.publisher_details import PublisherDetailsResponse
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.comic import StoryArc
+from src.db.models.comic import StoryArc
 from src.db.session import SessionDep
-from kontor_model.schema.comics.storyarc import StoryArcResponse, storyarc_to_response
+from src.schema.comics.storyarc import StoryArcResponse, storyarc_to_response
 
 router = APIRouter()
 

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.comic import Volume
+from src.db.models.comic import Volume
 from src.db.session import SessionDep
-from kontor_model.schema.comics.volume import VolumeResponse, volume_to_response
+from src.schema.comics.volume import VolumeResponse, volume_to_response
 
 router = APIRouter()
 

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.comic import WorkType
+from src.db.models.comic import WorkType
 from src.db.session import SessionDep
-from kontor_model.schema.comics.worktype import WorktypeResponse, worktype_to_response
+from src.schema.comics.worktype import WorktypeResponse, worktype_to_response
 
 
 router = APIRouter()

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

@@ -1,6 +1,6 @@
 from fastapi import APIRouter, status
 
-from kontor_model.schema.admin.healthcheck import HealthCheck
+from src.schema.admin.healthcheck import HealthCheck
 
 health_router = APIRouter()
 

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

@@ -2,10 +2,10 @@ from typing import List
 
 from fastapi import APIRouter, status, HTTPException
 from src.core.log_conf import logger
-from kontor_model.db.repository.media.actor import delete_mediaactor, import_mediaactor
+from src.db.repository.media.actor import delete_mediaactor, import_mediaactor
 from src.db.session import SessionDep
-from kontor_model.schema.media.actor import MediaActorModel, MediaActorResponse, actor_to_response
-from kontor_model.db.models.media import MediaActor
+from src.schema.media.actor import MediaActorModel, MediaActorResponse, actor_to_response
+from src.db.models.media import MediaActor
 
 router = APIRouter()
 

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

@@ -2,21 +2,21 @@ from typing import List
 
 from fastapi import APIRouter, status, HTTPException
 from src.core.log_conf import logger
-from kontor_model.db.repository.media.actorfile import (
+from src.db.repository.media.actorfile import (
     create_new_mediaactorfile,
     delete_mediaactorfile,
 )
-from kontor_model.db.repository.media.file import delete_mediafile, import_mediafile
+from src.db.repository.media.file import delete_mediafile, import_mediafile
 from src.db.session import SessionDep
-from kontor_model.schema.media.actor import MediaActorResponse, actor_to_response
-from kontor_model.schema.media.actorfile import MediaActorFileResponse, actorfile_to_response
-from kontor_model.schema.media.file import (
+from src.schema.media.actor import MediaActorResponse, actor_to_response
+from src.schema.media.actorfile import MediaActorFileResponse, actorfile_to_response
+from src.schema.media.file import (
     MediaFileModel,
     MediaFileResponse,
     file_to_response,
     file_to_model,
 )
-from kontor_model.db.models.media import MediaFile
+from src.db.models.media import MediaFile
 
 router = APIRouter()
 

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

@@ -1,91 +0,0 @@
-
-from typing import List
-
-from fastapi import APIRouter, status, HTTPException
-
-from kontor_model.db.models.media import MediaLofi
-from src.db.session import SessionDep
-from src.core.log_conf import logger
-from kontor_model.schema.media.lofi import (
-    MediaLofiModel,
-    MediaLofiResponse,
-    lofi_to_response,
-    lofi_to_model
-)
-from kontor_model.db.repository.media.lofi import (
-    import_medialofi,
-    delete_medialofi
-)
-
-
-router = APIRouter()
-
-@router.get("/lofi", response_model=List[MediaLofiResponse])
-def get_all_lofis(
-    db: SessionDep, review: bool = False, download: bool = False
-) -> List[MediaLofiResponse]:
-    """
-    Get all MediaLofis.
-    """
-    results: List[MediaLofiResponse] = []
-    lofis: List[MediaLofi]
-    if review:
-        lofis = db.query(MediaLofi).filter(MediaLofi.review.is_(True)).all()
-    elif download:
-        lofis = db.query(MediaLofi).filter(MediaLofi.should_download.is_(True)).all()
-    else:
-        lofis = db.query(MediaLofi).all()
-    for medialofi in lofis:
-        response = lofi_to_response(medialofi)
-        results.append(response)
-    return results
-
-@router.get("/lofi/{lofi_id}", response_model=MediaLofiResponse)
-def get_lofi(lofi_id: str, db: SessionDep) -> MediaLofiResponse:
-    """
-    Get MediaLofi by id.
-    """
-    lofi = db.get(MediaLofi, lofi_id)
-    if lofi is None:
-        raise HTTPException(status_code=404, detail="MediaLofi could not be found")
-    response = lofi_to_response(lofi)
-    return response
-
-@router.delete("/lofi/{lofi_id}", status_code=status.HTTP_204_NO_CONTENT)
-def delete_lofi(lofi_id: str, db: SessionDep):
-    """
-    Delete MediaFile by given id.
-    """
-    lofi = db.get(MediaLofi, lofi_id)
-    if not lofi:
-        raise HTTPException(status_code=404, detail="MediaLofi could not be found")
-    logger.info("delete MediaLofi: %s", lofi_id)
-    delete_medialofi(db=db, lofi_id=lofi.id)
-
-@router.put("/lofi/{lofi_id}", response_model=MediaLofiResponse)
-def update_lofi(lofi_id: str, db: SessionDep, info: MediaLofiResponse) -> MediaLofiResponse:
-    """
-    Update MediaLofi with given id and data.
-    """
-    media_lofi = db.get(MediaLofi, lofi_id)
-    if not media_lofi:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="MediaLofi could not be found")
-    lofi_to_model(info, media_lofi)
-    db.add(media_lofi)
-    db.commit()
-    media_lofi = db.get(MediaLofi, lofi_id)
-    if not media_lofi:
-        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="MediaLofi could not be found")
-    response = lofi_to_response(media_lofi)
-    return response
-
-    
-@router.post("/lofi", status_code=status.HTTP_201_CREATED)
-def add_lofi(new_lofi: MediaLofiModel, db: SessionDep) -> MediaLofiResponse:
-    logger.info("add medialofi %s", new_lofi)
-    try:
-        medialofi: MediaLofi = import_medialofi(db, new_lofi)
-    except:
-        raise HTTPException(status_code=409, detail="MediaLofi duplicate")
-    response = lofi_to_response(medialofi)
-    return response

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

@@ -1,10 +1,9 @@
 from typing import List
 from fastapi import APIRouter, status, HTTPException
-from src.core.log_conf import logger
-from kontor_model.db.models.media import MediaActorFile
-from kontor_model.db.repository.media.actorfile import delete_mediaactorfile, import_mediaactorfile
+from src.db.models.media import MediaActorFile
+from src.db.repository.media.actorfile import delete_mediaactorfile
 from src.db.session import SessionDep
-from kontor_model.schema.media.actorfile import MediaActorFileModel, MediaActorFileResponse, actorfile_to_response
+from src.schema.media.actorfile import MediaActorFileResponse, actorfile_to_response
 
 router = APIRouter()
 
@@ -31,13 +30,3 @@ def delete_actorfile(actorfile_id: str, db: SessionDep):
     if not media_actorfile:
         raise HTTPException(status_code=404, detail="MediaActor could not be found")
     delete_mediaactorfile(db, media_actorfile.id)
-
-@router.post("/actorfiles", status_code=status.HTTP_201_CREATED)
-def add_actorfile(new_actorfile: MediaActorFileModel, db: SessionDep) -> MediaActorFileResponse:
-    logger.info("add actorfile %s - %s", new_actorfile.media_actor_id, new_actorfile.media_file_id)
-    try:
-        mediaActorFile: MediaActorFile = import_mediaactorfile(db, new_actorfile)
-    except Exception as exception:
-        raise HTTPException(status_code=409, detail=f"Link duplicate: {exception}")
-    response = actorfile_to_response(mediaActorFile)
-    return response

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

@@ -3,9 +3,9 @@ from typing import List
 
 from fastapi import APIRouter
 
-from kontor_model.db.models.media import MediaArticle
+from src.db.models.media import MediaArticle
 from src.db.session import SessionDep
-from kontor_model.schema.media.article import MediaArticleResponse, to_response
+from src.schema.media.article import MediaArticleResponse, to_response
 
 router = APIRouter()
 

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

@@ -3,9 +3,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.media import MediaVideo
+from src.db.models.media import MediaVideo
 from src.db.session import SessionDep
-from kontor_model.schema.media.video import MediaVideoResponse, video_to_response
+from src.schema.media.video import MediaVideoResponse, video_to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.tysc import Card
+from src.db.models.tysc import Card
 from src.db.session import SessionDep
-from kontor_model.schema.tysc.card import CardResponse, to_response
+from src.schema.tysc.card import CardResponse, to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.tysc import CardSet
+from src.db.models.tysc import CardSet
 from src.db.session import SessionDep
-from kontor_model.schema.tysc.cardset import CardSetResponse, to_response
+from src.schema.tysc.cardset import CardSetResponse, to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.tysc import FieldPosition
+from src.db.models.tysc import FieldPosition
 from src.db.session import SessionDep
-from kontor_model.schema.tysc.fieldposition import FieldPositionResponse, to_response
+from src.schema.tysc.fieldposition import FieldPositionResponse, to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.tysc import Player
+from src.db.models.tysc import Player
 from src.db.session import SessionDep
-from kontor_model.schema.tysc.player import PlayerResponse, to_response
+from src.schema.tysc.player import PlayerResponse, to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.tysc import Rooster
+from src.db.models.tysc import Rooster
 from src.db.session import SessionDep
-from kontor_model.schema.tysc.rooster import RoosterResponse, to_response
+from src.schema.tysc.rooster import RoosterResponse, to_response
 
 
 router = APIRouter()

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

@@ -3,8 +3,8 @@ from fastapi import APIRouter, HTTPException
 
 from src.core.log_conf import logger
 from src.db.session import SessionDep
-from kontor_model.schema.tysc.sport import SportResponse, to_response
-from kontor_model.db.models.tysc import Sport
+from src.schema.tysc.sport import SportResponse, to_response
+from src.db.models.tysc import Sport
 
 router = APIRouter()
 

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.tysc import Team
+from src.db.models.tysc import Team
 from src.db.session import SessionDep
-from kontor_model.schema.tysc.team import TeamResponse, to_response
+from src.schema.tysc.team import TeamResponse, to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.tysc import Vendor
+from src.db.models.tysc import Vendor
 from src.db.session import SessionDep
-from kontor_model.schema.tysc.vendor import VendorResponse, to_response
+from src.schema.tysc.vendor import VendorResponse, to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.admin import Assignment
+from src.db.models.admin import Assignment
 from src.db.session import SessionDep
-from kontor_model.schema.user.assignment import AssignmentResponse, to_response
+from src.schema.user.assignment import AssignmentResponse, to_response
 
 router = APIRouter()
 

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter, HTTPException
 
-from kontor_model.db.models.admin import Permission
+from src.db.models.admin import Permission
 from src.db.session import SessionDep
-from kontor_model.schema.user.permission import PermissionResponse, to_response
+from src.schema.user.permission import PermissionResponse, to_response
 
 router = APIRouter()
 

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

@@ -4,10 +4,10 @@ from sqlalchemy import select
 from src.core.log_conf import logger
 
 from src.core.security import CurrentUser
-from kontor_model.db.models.admin import Profile
+from src.db.models.admin import Profile
 from src.db.repository.user import create_new_profile
 from src.db.session import SessionDep
-from kontor_model.schema.user.profile import ProfileResponse, ProfileModel, to_response
+from src.schema.user.profile import ProfileResponse, ProfileModel, to_response
 
 
 router = APIRouter()

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

@@ -2,9 +2,9 @@ from typing import List
 
 from fastapi import APIRouter
 
-from kontor_model.db.models.admin import Token
+from src.db.models.admin import Token
 from src.db.session import SessionDep
-from kontor_model.schema.user.token import TokenResponse, to_response
+from src.schema.user.token import TokenResponse, to_response
 
 router = APIRouter()
 

kontor-api/src/core/config.py

@@ -9,21 +9,17 @@ load_dotenv(dotenv_path=env_path)
 
 class Settings:
     PROJECT_NAME: str = "Kontor"
-    PROJECT_VERSION: str = "0.4.0"
+    PROJECT_VERSION: str = "0.3.0"
 
     DB_USER: str = os.getenv("DB_USER", "kontor")
     DB_PASSWORD: str = os.getenv("DB_PASSWORD", "kontor")
     DB_SERVER: str = os.getenv("DB_SERVER", "postgres")
     DB_PORT: int = int(os.getenv("DB_PORT", 5432))
     DB_DBNAME: str = os.getenv("DB_DBNAME", "kontor")
-    DATABASE_URL: str = (
-        f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_SERVER}:{DB_PORT}/{DB_DBNAME}"
-    )
-    SECRET_KEY: str = os.getenv(
-        "SECRET_KEY", "J6GOtcwC2NJI1l0VkHu20PacPFGTxpirBxWwynoHjsc="
-    )
+    DATABASE_URL: str = f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_SERVER}:{DB_PORT}/{DB_DBNAME}"
+    SECRET_KEY: str = os.getenv("SECRET_KEY", "J6GOtcwC2NJI1l0VkHu20PacPFGTxpirBxWwynoHjsc=")
     ALGORITHM = "HS256"
     ACCESS_TOKEN_EXPIRE_MINUTES = 60*24*7  # one week in mins
 
-
 settings = Settings()
+

kontor-api/src/core/security.py

@@ -15,15 +15,15 @@ from pydantic import ValidationError
 
 from src.core.config import settings
 from src.core.log_conf import logger
-from kontor_model.db.models.admin import Profile
-from kontor_model.db.repository.admin import (
+from src.db.models.admin import Profile
+from src.db.repository.admin import (
     get_profile_by_username,
     get_profile_by_email,
     is_database_empty,
 )
 from src.db.session import SessionLocal
-from kontor_model.schema.admin.token import TokenData
-from kontor_model.schema.user.profile import ProfileModel, to_model
+from src.schema.admin.token import TokenData
+from src.schema.user.profile import ProfileModel, to_model
 
 oauth2_scheme = OAuth2PasswordBearer(
     tokenUrl="/token",
@@ -163,7 +163,7 @@ async def get_current_user(
 async def get_current_active_user(
     current_user: Annotated[Profile, Security(get_current_user, scopes=["me"])],
 ) -> ProfileModel:
-    if not bool(current_user.enabled):
+    if not current_user.enabled:
         raise HTTPException(status_code=400, detail="Inactive user")
     user_model = to_model(current_user)
     return user_model

kontor-api/src/db/models/admin.py

@@ -0,0 +1,75 @@
+from datetime import datetime
+from typing import List
+
+from sqlalchemy import ForeignKey
+from sqlalchemy.orm import relationship, mapped_column, Mapped
+
+from src.db.models.base import Base, BaseMixin
+
+
+class Profile(Base, BaseMixin):
+    __tablename__ = 'profile'
+    first_name: Mapped[str]
+    last_name: Mapped[str]
+    user_name: Mapped[str] =  mapped_column(nullable=False)
+    email: Mapped[str]
+    password: Mapped[str]
+    enabled: Mapped[bool]
+    assignments: Mapped[List["Assignment"]] = relationship(back_populates="profile")
+    tokens: Mapped[List["Token"]] = relationship(back_populates="profile")
+
+    def get_full_name(self) -> str:
+        full_name: str = ""
+        if self.first_name is not None:
+            full_name += str(self.first_name)
+        if self.last_name is not None:
+            if len(full_name) > 0:
+                full_name += " "
+            full_name += str(self.last_name)
+        return full_name
+
+    def __str__(self):
+        return f"Profile({self.id} {self.user_name}, {self.email})"
+
+
+class Token(Base, BaseMixin):
+    __tablename__ = "token"
+    token: Mapped[str] = mapped_column(nullable=False, unique=True)
+    name: Mapped[str]
+    last_used_date: Mapped[datetime]
+    enabled: Mapped[bool]
+    profile_id = mapped_column(ForeignKey("profile.id"), nullable=False)
+    profile: Mapped[Profile] = relationship(back_populates="tokens")
+
+
+class Permission(Base, BaseMixin):
+    __tablename__ = "permission"
+    name: Mapped[str] = mapped_column(nullable=False)
+    assignments: Mapped[List["Assignment"]] = relationship(back_populates="permission")
+
+
+class Assignment(Base, BaseMixin):
+    __tablename__ = "assignment"
+    profile_id = mapped_column(ForeignKey("profile.id"), nullable=False)
+    profile: Mapped[Profile] = relationship(back_populates="assignments")
+    permission_id = mapped_column(ForeignKey("permission.id"), nullable=False)
+    permission: Mapped[Permission] = relationship(back_populates="assignments")
+
+
+class MailAccount(Base, BaseMixin):
+    __tablename__ = "mail_account"
+    host: Mapped[str]
+    port: Mapped[int]
+    protocol: Mapped[str]
+    user_name: Mapped[str]
+    password: Mapped[str]
+    start_tls: Mapped[bool]
+
+
+class Mail(Base, BaseMixin):
+    __tablename__ = "mail"
+    folder: Mapped[str]
+    subject: Mapped[str]
+    body: Mapped[str]
+    sent_date: Mapped[datetime]
+    received_date: Mapped[datetime]

kontor-api/src/db/models/base.py

@@ -1,31 +1,16 @@
-"""
-Definition of models
-"""
-
 from typing import Optional
 import uuid
 from datetime import datetime
 
-from sqlalchemy import create_engine, func
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, sessionmaker
-
-DATABASE_URL = "sqlite:///./kontor.db"
-
-engine = create_engine(DATABASE_URL)
-SESSION_LOCAL = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+from sqlalchemy import func
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
 
 class Base(DeclarativeBase):
-    """
-    Base class for all Models
-    """
+    pass
 
 
 class BaseMixin:
-    """
-    Base mixin to provide standard fields id, version, created_date, last_modified_date
-    """
-
     id: Mapped[str] = mapped_column(primary_key=True, default=str(uuid.uuid4()))
     created_date: Mapped[datetime] = mapped_column(default=func.now())
     last_modified_date: Mapped[datetime] = mapped_column(default=func.now())
@@ -33,10 +18,6 @@ class BaseMixin:
 
 
 class BaseVideoMixin:
-    """
-    Base mixin to provide additional fields for video links.
-    """
-
     cloud_link: Mapped[Optional[str]]
     file_name: Mapped[Optional[str]]
     path: Mapped[str]

kontor-api/src/db/models/bookshelf.py

@@ -0,0 +1,52 @@
+from typing import List
+
+from sqlalchemy import Column, ForeignKey, Integer, String
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from src.db.models.base import Base, BaseMixin
+
+
+class Article(Base, BaseMixin):
+    __tablename__ = 'article'
+    title: Mapped[str] = mapped_column(unique=True)
+    article_authors = relationship("ArticleAuthor")
+
+
+class Author(Base, BaseMixin):
+    __tablename__ = 'author'
+    first_name: Mapped[str]
+    last_name: Mapped[str]
+    article_authors: Mapped[List["ArticleAuthor"]] = relationship(back_populates="author")
+    book_authors: Mapped[List["BookAuthor"]] = relationship(back_populates="author")
+
+
+class BookshelfPublisher(Base, BaseMixin):
+    __tablename__ = 'bookshelf_publisher'
+    name: Mapped[str] = mapped_column(unique=True)
+    books: Mapped[List["Book"]] = relationship(back_populates="publisher")
+
+
+class Book(Base, BaseMixin):
+    __tablename__ = 'book'
+    isbn: Mapped[str] = mapped_column(unique=True)
+    title: Mapped[str]
+    year: Mapped[int] = mapped_column(nullable=False)
+    publisher_id: Mapped[str] = mapped_column(ForeignKey("bookshelf_publisher.id"), nullable=False)
+    publisher: Mapped[BookshelfPublisher] = relationship(back_populates="books")
+    book_authors: Mapped[List["BookAuthor"]] = relationship(back_populates="book")
+
+
+class ArticleAuthor(Base, BaseMixin):
+    __tablename__ = 'article_author'
+    article_id: Mapped[str] = mapped_column(ForeignKey("article.id"), nullable=False)
+    article: Mapped[Article] = relationship(back_populates="article_authors")
+    author_id: Mapped[str] = mapped_column(ForeignKey("author.id"), nullable=False)
+    author: Mapped[Author] = relationship(back_populates="article_authors")
+
+
+class BookAuthor(Base, BaseMixin):
+    __tablename__ = 'book_author'
+    author_id: Mapped[str] = mapped_column(ForeignKey("author.id"), nullable=False)
+    author: Mapped[Author] = relationship(back_populates="book_authors")
+    book_id: Mapped[str] = mapped_column(ForeignKey("book.id"), nullable=False)
+    book: Mapped[Book] = relationship(back_populates="book_authors")

kontor-api/src/db/models/comic.py

@@ -0,0 +1,188 @@
+import uuid
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from natsort import natsorted
+from sqlalchemy import ForeignKey, func
+from sqlalchemy.orm import relationship, Mapped, mapped_column
+
+from src.db.models.base import Base, BaseMixin
+
+
+class Publisher(Base):
+    __tablename__ = "publisher"
+    id: Mapped[str] = mapped_column(primary_key=True, default=uuid.uuid4)
+    created_date: Mapped[datetime] = mapped_column(default=func.now())
+    last_modified_date: Mapped[datetime] = mapped_column(default=func.now())
+    version: Mapped[int] = mapped_column(default=0)
+    name: Mapped[str] = mapped_column(unique=True)
+    weblink: Mapped[Optional[str]]
+    parent_publisher_id: Mapped[Optional[str]] = mapped_column(ForeignKey('publisher.id'))
+    parent_publisher: Mapped[Optional['Publisher']] = relationship(back_populates="imprints", remote_side=[id])
+    imprints: Mapped[List['Publisher']] = relationship(back_populates="parent_publisher")
+    comics: Mapped[List["Comic"]] = relationship(back_populates="publisher")
+
+    def __repr__(self):
+        return f'Publisher({self.id} {self.name})'
+
+    def __str__(self):
+        return self.__repr__()
+
+
+class Comic(Base, BaseMixin):
+    __tablename__ = 'comic'
+    title: Mapped[str] = mapped_column(unique=True)
+    publisher_id: Mapped[str] = mapped_column(ForeignKey('publisher.id'), nullable=False)
+    publisher: Mapped[Publisher] = relationship(back_populates="comics")
+    current_order: Mapped[bool]
+    completed: Mapped[bool]
+    weblink: Mapped[Optional[str]]
+    issues: Mapped[List["Issue"]] = relationship(back_populates="comic", order_by="Issue.issue_number")
+    story_arcs: Mapped[List["StoryArc"]] = relationship(back_populates="comic")
+    trade_paperbacks: Mapped[List["TradePaperback"]] = relationship(back_populates="comic")
+    volumes: Mapped[List["Volume"]] = relationship(back_populates="comic")
+    comic_works: Mapped[List["ComicWork"]] = relationship(back_populates="comic")
+
+    def __repr__(self):
+        return f'Comic({self.id} {self.version} {self.title} {self.publisher.name})'
+
+    def __str__(self):
+        return f'{self.title}({self.id})'
+
+    def get_artists(self) -> Dict[Any, List[Any]]:
+        works: Dict[Any, List[Any]] = {}
+        for work in self.comic_works:
+            work_type = work.work_type
+            artist = work.artist
+            if work_type in works:
+                works[work_type].append(artist)
+            else:
+                works[work_type] = [artist]
+        return works
+
+    def sorted_issues(self):
+        sorted_issues = natsorted(self.issues, key=lambda x: getattr(x, 'issue_number'))
+        return sorted_issues
+
+
+class Volume(Base, BaseMixin):
+    __tablename__ = "volume"
+    name: Mapped[str] = mapped_column(nullable=False)
+    comic_id: Mapped[str] = mapped_column(ForeignKey("comic.id"), nullable=False)
+    comic: Mapped[Comic] = relationship(back_populates="volumes")
+    story_arcs: Mapped[List["StoryArc"]] = relationship(back_populates="volume")
+    issues: Mapped[List["Issue"]] = relationship(back_populates="volume")
+
+
+class TradePaperback(Base, BaseMixin):
+    __tablename__ = "trade_paperback"
+    name: Mapped[str] = mapped_column(nullable=False)
+    issue_start: Mapped[int]
+    issue_end: Mapped[int]
+    comic_id: Mapped[str] = mapped_column(ForeignKey("comic.id"), nullable=False)
+    comic: Mapped[Comic] = relationship(back_populates="trade_paperbacks")
+
+
+class StoryArc(Base, BaseMixin):
+    __tablename__ = "story_arc"
+    name: Mapped[str] = mapped_column(nullable=False)
+    comic_id: Mapped[str] = mapped_column(ForeignKey("comic.id"), nullable=False)
+    comic: Mapped[Comic] = relationship(back_populates="story_arcs")
+    volume_id: Mapped[str] = mapped_column(ForeignKey("volume.id"), nullable=True)
+    volume: Mapped[Volume] = relationship(back_populates="story_arcs")
+    issues: Mapped[List["Issue"]] = relationship(back_populates="story_arc")
+
+
+class Issue(Base, BaseMixin):
+    __tablename__ = "issue"
+    issue_number: Mapped[str]
+    title: Mapped[Optional[str]]
+    published_on: Mapped[Optional[datetime]]
+    in_stock: Mapped[bool]
+    is_read: Mapped[bool]
+    comic_id: Mapped[str] = mapped_column(ForeignKey("comic.id"), nullable=False)
+    comic: Mapped[Comic] = relationship(back_populates="issues")
+    volume_id: Mapped[str] = mapped_column(ForeignKey("volume.id"), nullable=True)
+    volume: Mapped[Volume] = relationship(back_populates="issues")
+    story_arc_id: Mapped[str] = mapped_column(ForeignKey("story_arc.id"), nullable=True)
+    story_arc: Mapped[StoryArc] = relationship(back_populates="issues")
+    issue_works: Mapped[List["IssueWork"]] = relationship(back_populates="issue")
+
+    def get_full_title(self) -> str:
+        full_title: str = str(self.issue_number)
+        if self.title:
+            full_title += str(": " + self.title)
+        return full_title
+
+    def get_artists(self) -> Dict[Any, List[Any]]:
+        works: Dict[Any, List[Any]] = {}
+        for work in self.issue_works:
+            work_type = work.work_type
+            artist = work.artist
+            if work_type in works:
+                works[work_type].append(artist)
+            else:
+                works[work_type] = [artist]
+        return works
+
+
+class Artist(Base, BaseMixin):
+    __tablename__ = "artist"
+    name: Mapped[str] = mapped_column(nullable=False)
+    weblink: Mapped[str] = mapped_column(nullable=True)
+    comic_works: Mapped[List["ComicWork"]] = relationship(back_populates="artist")
+    issue_works: Mapped[List["IssueWork"]] = relationship(back_populates="artist")
+
+    def get_comics(self) -> Dict[Any, List[Comic]]:
+        works: Dict[Any, List[Comic]] = {}
+        for work in self.comic_works:
+            work_type = work.work_type
+            comic = work.comic
+            if work_type in works:
+                works[work_type].append(comic)
+            else:
+                works[work_type] = [comic]
+        return works
+
+
+class WorkType(Base, BaseMixin):
+    __tablename__ = "worktype"
+    name: Mapped[str] = mapped_column(nullable=False, unique=True)
+    comic_works: Mapped[List["ComicWork"]] = relationship(back_populates="work_type")
+    issue_works: Mapped[List["IssueWork"]] = relationship(back_populates="work_type")
+
+    def get_artists(self) -> Dict[str, List[Artist]]:
+        works: Dict[str, List[Artist]] = {}
+        for work in self.comic_works:
+            comic = work.comic.title
+            artist = work.artist
+            if comic in works:
+                works[comic].append(artist)
+            else:
+                works[comic] = [artist]
+        return works
+
+    def __repr__(self):
+        return f'Worktype({self.id} {self.version} {self.name} {len(self.comic_works)})'
+
+    def __str__(self):
+        return f'{self.name}({self.id})'
+
+
+class ComicWork(Base, BaseMixin):
+    __tablename__ = "comic_work"
+    comic_id: Mapped[str] = mapped_column(ForeignKey("comic.id"), nullable=False)
+    comic: Mapped[Comic] = relationship(back_populates="comic_works")
+    artist_id: Mapped[str] = mapped_column(ForeignKey("artist.id"), nullable=False)
+    artist: Mapped[Artist] = relationship(back_populates="comic_works")
+    work_type_id: Mapped[str] = mapped_column(ForeignKey("worktype.id"), nullable=False)
+    work_type: Mapped[WorkType] = relationship(back_populates="comic_works")
+
+
+class IssueWork(Base, BaseMixin):
+    __tablename__ = "issue_work"
+    issue_id: Mapped[str] = mapped_column(ForeignKey("issue.id"), nullable=False)
+    issue: Mapped[Issue] = relationship(back_populates="issue_works")
+    artist_id: Mapped[str] = mapped_column(ForeignKey("artist.id"), nullable=False)
+    artist: Mapped[Artist] = relationship(back_populates="issue_works")
+    work_type_id: Mapped[str] = mapped_column(ForeignKey("worktype.id"), nullable=False)
+    work_type: Mapped[WorkType] = relationship(back_populates="issue_works")

kontor-api/src/db/models/media.py

@@ -1,9 +1,16 @@
+import logging
+import re
+import subprocess
+from datetime import datetime
+from pathlib import Path
 from typing import List, Optional
 
+import requests
+from bs4 import BeautifulSoup
 from sqlalchemy import ForeignKey
 from sqlalchemy.orm import Mapped, relationship, mapped_column
 
-from kontor_robyn.db.models import Base, BaseMixin, BaseVideoMixin
+from src.db.models.base import Base, BaseMixin, BaseVideoMixin
 
 
 class MediaFile(Base, BaseMixin, BaseVideoMixin):
@@ -29,10 +36,6 @@ class MediaFile(Base, BaseMixin, BaseVideoMixin):
 
 
 class MediaActor(Base, BaseMixin):
-    """
-    MediaActor represents actor for MediaFile
-    """
-
     __tablename__ = "media_actor"
     name: Mapped[str]
     url: Mapped[Optional[str]] = mapped_column(unique=True)
@@ -46,10 +49,6 @@ class MediaActor(Base, BaseMixin):
 
 
 class MediaActorFile(Base, BaseMixin):
-    """
-    MediaActorFile defines the connection between MediaFile and MediaActor
-    """
-
     __tablename__ = "media_actor_file"
     media_actor_id: Mapped[str] = mapped_column(
         ForeignKey("media_actor.id"), nullable=False
@@ -68,10 +67,6 @@ class MediaActorFile(Base, BaseMixin):
 
 
 class MediaArticle(Base, BaseMixin):
-    """
-    MediaArticle represents a link to an article
-    """
-
     __tablename__ = "media_article"
     review: Mapped[bool]
     title: Mapped[str]

kontor-api/src/db/models/tysc.py

@@ -0,0 +1,100 @@
+from typing import List
+from sqlalchemy import ForeignKey, UniqueConstraint
+from sqlalchemy.orm import relationship, mapped_column, Mapped
+
+from src.db.models.base import Base, BaseMixin
+
+
+class Sport(Base, BaseMixin):
+    __tablename__ = "sport"
+    __table_args__ = (
+        UniqueConstraint("name"),
+    )
+    name: Mapped[str] = mapped_column(nullable=False, index=True, unique=True)
+    teams: Mapped[List["Team"]] = relationship(back_populates="sport")
+    positions: Mapped[List["FieldPosition"]] = relationship(back_populates="sport")
+
+
+class Team(Base, BaseMixin):
+    __tablename__ = "team"
+    name: Mapped[str] = mapped_column(nullable=False, index=True, unique=True)
+    short_name: Mapped[str] = mapped_column(nullable=False)
+    sport_id: Mapped[str] = mapped_column(ForeignKey("sport.id"), nullable=False)
+    sport: Mapped[Sport] = relationship(back_populates="teams")
+    roosters: Mapped[List["Rooster"]] = relationship(back_populates="team")
+
+
+class FieldPosition(Base, BaseMixin):
+    __tablename__ = "field_position"
+    __table_args__ = (
+        UniqueConstraint("name", "sport_id"),
+        UniqueConstraint("short_name", "sport_id"),
+    )
+    name: Mapped[str] = mapped_column(nullable=False, index=True)
+    short_name: Mapped[str] = mapped_column(nullable=False)
+    sport_id: Mapped[str] = mapped_column(ForeignKey("sport.id"), nullable=False, index=True)
+    sport: Mapped[Sport] = relationship(back_populates="positions")
+    roosters: Mapped[List["Rooster"]] = relationship(back_populates="position")
+
+
+class Player(Base, BaseMixin):
+    __tablename__ = "player"
+    __table_args__ = (
+        UniqueConstraint("first_name", "last_name"),
+    )
+    first_name: Mapped[str] = mapped_column(nullable=False, index=True)
+    last_name: Mapped[str] = mapped_column(nullable=False, index=True)
+    roosters: Mapped[List["Rooster"]] = relationship(back_populates="player")
+
+    def get_full_name(self) -> str:
+        return f"{self.last_name}, {self.first_name}"
+
+
+class Rooster(Base, BaseMixin):
+    __tablename__ = "rooster"
+    __table_args__ = (
+        UniqueConstraint("year", "team_id", "player_id", "position_id"),
+    )
+    year: Mapped[int]
+    team_id: Mapped[str] = mapped_column(ForeignKey("team.id"), nullable=False, index=True)
+    team: Mapped[Team] = relationship(back_populates="roosters")
+    player_id: Mapped[str] = mapped_column(ForeignKey("player.id"), nullable=False, index=True)
+    player: Mapped[Player] = relationship(back_populates="roosters")
+    position_id: Mapped[str] = mapped_column(ForeignKey("field_position.id"), nullable=False, index=True)
+    position: Mapped[FieldPosition] = relationship(back_populates="roosters")
+    cards: Mapped[List["Card"]] = relationship(back_populates="rooster")
+
+
+class Vendor(Base, BaseMixin):
+    __tablename__ = "vendor"
+    name: Mapped[str] = mapped_column(nullable=False, unique=True, index=True)
+    card_sets: Mapped[List["CardSet"]] = relationship(back_populates="vendor")
+    cards: Mapped[List["Card"]] = relationship(back_populates="vendor")
+
+
+class CardSet(Base, BaseMixin):
+    __tablename__ = "card_set"
+    __table_args__ = (
+        UniqueConstraint("name", "vendor_id"),
+    )
+    name: Mapped[str] = mapped_column(index=True)
+    parallel_set: Mapped[bool]
+    insert_set: Mapped[bool]
+    vendor_id: Mapped[str] = mapped_column(ForeignKey("vendor.id"), nullable=False, index=True)
+    vendor: Mapped[Vendor] = relationship(back_populates="card_sets")
+    cards: Mapped[List["Card"]] = relationship(back_populates="card_set")
+
+
+class Card(Base, BaseMixin):
+    __tablename__ = "card"
+    __table_args__ = (
+        UniqueConstraint("card_number", "year", "vendor_id", "card_set_id"),
+    )
+    card_number: Mapped[int] = mapped_column(index=True)
+    year: Mapped[int] = mapped_column(index=True)
+    card_set_id: Mapped[str] = mapped_column(ForeignKey("card_set.id"), nullable=False)
+    card_set: Mapped[CardSet] = relationship(back_populates="cards")
+    rooster_id: Mapped[str] = mapped_column(ForeignKey("rooster.id"), nullable=False)
+    rooster: Mapped[Rooster] = relationship(back_populates="cards")
+    vendor_id: Mapped[str] = mapped_column(ForeignKey("vendor.id"), nullable=False)
+    vendor: Mapped[Vendor] = relationship(back_populates="cards")

kontor-api/src/db/repository/admin.py

@@ -2,7 +2,7 @@ from typing import Optional
 
 from sqlalchemy.orm import Session
 
-from kontor_model.db.models.admin import Profile
+from src.db.models.admin import Profile
 
 
 def get_profile_by_username(username: str, db: Session) -> Optional[Profile]:

kontor-api/src/db/repository/comics/artist.py

@@ -1,12 +1,14 @@
+import uuid
 from typing import List, Optional
 
 from sqlalchemy.orm import Session
 
-from kontor_model.db.models.comic import Artist
-from kontor_model.schema.comics.artist import AddArtist
-from kontor_model.schema.comics.artist_details import ArtistDetailResponse, ArtistWorktypeComicResponse, ArtistWorktypeIssueResponse
-from kontor_model.schema.comics.comic import ComicResponse
-from kontor_model.schema.comics.worktype import WorktypeResponse
+from src.core.log_conf import logger
+from src.db.models.comic import Artist
+from src.schema.comics.artist import AddArtist
+from src.schema.comics.artist_details import ArtistDetailResponse, ArtistWorktypeComicResponse, ArtistWorktypeIssueResponse
+from src.schema.comics.comic import ComicResponse
+from src.schema.comics.worktype import WorktypeResponse
 
 
 def get_artist_details(artist: Artist) -> ArtistDetailResponse:
@@ -15,17 +17,7 @@ def get_artist_details(artist: Artist) -> ArtistDetailResponse:
     for work in artist.comic_works:
         worktype_id = work.work_type.id
         if worktype_id in comic_works_map:
-            comic = ComicResponse(
-                id=work.comic.id,
-                created_date=work.comic.created_date,
-                last_modified_date=work.comic.last_modified_date,
-                version=work.comic.version,
-                publisher_id=work.comic.publisher_id,
-                current_order=work.comic.current_order,
-                weblink=work.comic.weblink,
-                title=work.comic.title, 
-                completed=work.comic.completed
-            )
+            comic = ComicResponse(id=work.comic.id, title=work.comic.title, completed=work.comic.completed)
             comic_works_map[worktype_id].comics.append(comic)
         else:
             comic_works_map[worktype_id] = ArtistWorktypeComicResponse(
@@ -45,6 +37,7 @@ def get_artist_details(artist: Artist) -> ArtistDetailResponse:
     return response
 
 def update_artist(add_artist: AddArtist, artist_id: str, db: Session) -> Optional[Artist]:
+    logger.info("update artist")
     artist: Optional[Artist] = db.get(Artist, artist_id)
     if artist is not None:
         artist.name = add_artist.name

kontor-api/src/db/repository/comics/comic.py

@@ -2,15 +2,16 @@ from typing import Dict, List, Optional
 
 from sqlalchemy.orm import Session
 
-from kontor_model.db.models.comic import Comic, Issue
-from kontor_model.schema.comics.artist import artist_to_response
-from kontor_model.schema.comics.comic import ComicSchema, comic_to_response
-from kontor_model.schema.comics.comic_details import ComicDetailsResponse, ComicWorktypeArtistResponse
-from kontor_model.schema.comics.issue import IssueResponse, issue_to_response
-from kontor_model.schema.comics.issue_details import IssueDetailsResponse
-from kontor_model.schema.comics.publisher import publisher_to_response
-from kontor_model.schema.comics.volume import VolumeResponse, volume_to_response
-from kontor_model.schema.comics.worktype import worktype_to_response
+from src.core.log_conf import logger
+from src.db.models.comic import Comic, Issue
+from src.schema.comics.artist import artist_to_response
+from src.schema.comics.comic import ComicSchema, comic_to_response
+from src.schema.comics.comic_details import ComicDetailsResponse, ComicWorktypeArtistResponse
+from src.schema.comics.issue import IssueResponse, issue_to_response
+from src.schema.comics.issue_details import IssueDetailsResponse
+from src.schema.comics.publisher import publisher_to_response
+from src.schema.comics.volume import VolumeResponse, volume_to_response
+from src.schema.comics.worktype import worktype_to_response
 
 
 def get_issue_details(issue: Issue) -> IssueDetailsResponse:
@@ -29,6 +30,7 @@ def get_issue_details(issue: Issue) -> IssueDetailsResponse:
 
 
 def update_comic(new_comic: ComicSchema, comic_id: str, db: Session) -> Optional[Comic]:
+    logger.info(f"update_comic: {new_comic} with {comic_id}")
     comic: Optional[Comic] = db.get(Comic, comic_id)
     return comic
 
@@ -46,6 +48,7 @@ def get_comic_details(comic: Comic) -> ComicDetailsResponse:
         if worktype_id in works_map:
             artist = artist_to_response(work.artist)
             works_map[worktype_id].artists.append(artist)
+            logger.info(f"add artist to response map: {artist} -> {works_map}")
             print(f"add artist to response map: {artist} -> {works_map}")
         else:
             works_map[worktype_id] = ComicWorktypeArtistResponse(

kontor-api/src/db/repository/comics/publisher.py

@@ -0,0 +1,24 @@
+from typing import List
+
+from src.db.models.comic import Publisher
+from src.schema.comics.comic import ComicResponse
+from src.schema.comics.publisher import PublisherResponse
+from src.schema.comics.publisher_details import PublisherDetailsResponse
+
+
+def get_publisher_details(publisher: Publisher) -> PublisherDetailsResponse:
+    imprints: List[PublisherResponse] = []
+    for imprint in publisher.imprints:
+        imprints.append(PublisherResponse(id=imprint.id, name=str(imprint.name)))
+    comics: List[ComicResponse] = []
+    for comic in publisher.comics:
+        comics.append(
+            ComicResponse(id=comic.id, title=comic.title, completed=comic.completed)
+        )
+    parent_publisher: PublisherResponse | None = None
+    if publisher.parent_publisher:
+        parent_publisher = PublisherResponse(id=publisher.parent_publisher.id, name=str(publisher.parent_publisher.name))
+    response: PublisherDetailsResponse = PublisherDetailsResponse(
+        id=publisher.id, name=str(publisher.name), parent_publisher=parent_publisher, imprints=imprints, comics=comics
+    )
+    return response

kontor-api/src/db/repository/comics/worktype.py

@@ -4,8 +4,9 @@ from typing import AnyStr, Optional
 
 from sqlalchemy.orm import Session
 
-from kontor_model.db.models.comic import WorkType
-from kontor_model.schema.comics.worktype import AddWorkType
+from src.core.log_conf import logger
+from src.db.models.comic import WorkType
+from src.schema.comics.worktype import AddWorkType
 
 
 def create_new_worktype(work: AddWorkType, db: Session) -> WorkType:
@@ -17,10 +18,12 @@ def create_new_worktype(work: AddWorkType, db: Session) -> WorkType:
     db.add(worktype)
     db.commit()
     db.refresh(worktype)
+    logger.info(f"create_new_worktype: {worktype}")
     return worktype
 
 
 def update_worktype(work: AddWorkType, worktype_id: AnyStr, db: Session) -> Optional[WorkType]:
+    logger.info("update worktype")
     worktype: Optional[WorkType] = db.get(WorkType, worktype_id)
     if worktype is not None:
         worktype.name = work.worktype

kontor-api/src/db/repository/media/actor.py

@@ -3,13 +3,14 @@ import uuid
 
 from sqlalchemy.orm import Session
 
-from kontor_model.db.models.media import MediaActor
-from kontor_model.db.repository.media.actorfile import delete_mediaactorfile
-from kontor_model.schema.media.actor import MediaActorModel
+from src.core.log_conf import logger
+from src.db.models.media import MediaActor
+from src.db.repository.media.actorfile import delete_mediaactorfile
+from src.schema.media.actor import MediaActorModel
 
 
 def create_new_mediaactor(new_actor: MediaActorModel, db: Session) -> MediaActor:
-    print(f"create MediaActor with url {new_actor.url}")
+    logger.info(f"create MediaActor with url {new_actor.url}")
     media_actor: MediaActor = MediaActor()
     media_actor.id = str(uuid.uuid4())
     if new_actor.name is not None:
@@ -21,11 +22,11 @@ def create_new_mediaactor(new_actor: MediaActorModel, db: Session) -> MediaActor
     db.add(media_actor)
     db.commit()
     db.refresh(media_actor)
-    print(f"created {media_actor}")
+    logger.info(f"created {media_actor}")
     return media_actor
 
 def delete_mediaactor(db: Session, actor_id: str):
-    print(f"delete MediaActor with id {actor_id}")
+    logger.info(f"delete MediaActor with id {actor_id}")
     media_actor = db.get(MediaActor, actor_id)
     if media_actor is not None:
         actor_files = media_actor.media_actor_files
@@ -39,7 +40,7 @@ def import_mediaactor(db: Session, new_actor: MediaActorModel) -> MediaActor:
     """
     import MediaFile and set missing values with default ones.
     """
-    print("import MediaActor with %s", new_actor)
+    logger.info("import MediaActor with %s", new_actor)
     media_actor: MediaActor = MediaActor()
     media_actor.id = new_actor.id
     if new_actor.created_date:

kontor-api/src/db/repository/media/actorfile.py

@@ -3,8 +3,9 @@ import uuid
 
 from sqlalchemy.orm import Session
 
-from kontor_model.db.models.media import MediaActorFile
-from kontor_model.schema.media.actorfile import MediaActorFileModel
+from src.core.log_conf import logger
+from src.db.models.media import MediaActorFile
+from src.schema.media.actorfile import MediaActorFileModel
 
 
 def create_new_mediaactorfile(
@@ -13,7 +14,7 @@ def create_new_mediaactorfile(
     """
     Create relation for MediaFile and MediaActor
     """
-    print("create MediaActorFile with actor %s and file %s", actor_id, file_id)
+    logger.info("create MediaActorFile with actor %s and file %s", actor_id, file_id)
     media_actor_file: MediaActorFile = MediaActorFile()
     media_actor_file.id = str(uuid.uuid4())
     media_actor_file.created_date = datetime.now()
@@ -31,7 +32,7 @@ def delete_mediaactorfile(db: Session, actorfile_id: str):
     """
     Delete relation between MediaFile and MediaActor.
     """
-    print("delete MediaActorFile with id %s", actorfile_id)
+    logger.info("delete MediaActorFile with id %s", actorfile_id)
     media_actorfile = db.get(MediaActorFile, actorfile_id)
     db.delete(media_actorfile)
     db.commit()
@@ -43,21 +44,6 @@ def import_mediaactorfile(
     """
     Import MediaFile and set missing values with default ones.
     """
-    print("import MediaActorFile with %s", new_actorfile)
+    logger.info("import MediaActorFile with %s", new_actorfile)
     media_actor_file: MediaActorFile = MediaActorFile()
-    media_actor_file.id = new_actorfile.id
-    if new_actorfile.created_date:
-        media_actor_file.created_date = new_actorfile.created_date
-    else:
-        media_actor_file.created_date = datetime.now()
-    if new_actorfile.last_modified_date:
-        media_actor_file.last_modified_date = new_actorfile.last_modified_date
-    else:
-        media_actor_file.last_modified_date = datetime.now()
-    media_actor_file.version = new_actorfile.version
-    media_actor_file.media_actor_id = new_actorfile.media_actor_id
-    media_actor_file.media_file_id = new_actorfile.media_file_id
-    db.add(media_actor_file)
-    db.commit()
-    db.refresh(media_actor_file)
     return media_actor_file

kontor-api/src/db/repository/media/file.py

@@ -3,15 +3,16 @@ import uuid
 
 from sqlalchemy.orm import Session
 
-from kontor_model.db.models.media import MediaFile
-from kontor_model.schema.media.file import MediaFileModel
+from src.core.log_conf import logger
+from src.db.models.media import MediaFile
+from src.schema.media.file import MediaFileModel
 
 
 def create_new_mediafile(link: str, db: Session) -> MediaFile:
     """
     Create MediaFile with gievne URL.
     """
-    print("create MediaFile with url {link}")
+    logger.info("create MediaFile with url {link}")
     media_file: MediaFile = MediaFile()
     media_file.id = str(uuid.uuid4())
     media_file.url = link
@@ -23,7 +24,7 @@ def create_new_mediafile(link: str, db: Session) -> MediaFile:
     db.add(media_file)
     db.commit()
     db.refresh(media_file)
-    print("created %s", media_file)
+    logger.info("created %s", media_file)
     return media_file
 
 
@@ -31,7 +32,7 @@ def delete_mediafile(db: Session, media_file_id: str):
     """
     Delete MediaFile with given ID from db.
     """
-    print("delete MediaFile with id %s", media_file_id)
+    logger.info("delete MediaFile with id %s", media_file_id)
     media_file = db.get(MediaFile, media_file_id)
     db.delete(media_file)
     db.commit()
@@ -41,7 +42,7 @@ def import_mediafile(db: Session, new_file: MediaFileModel) -> MediaFile:
     """
     import MediaActor and set missing values with defautl ones.
     """
-    print("import MediaFile with %s", new_file)
+    logger.info("import MediaFile with %s", new_file)
     media_file: MediaFile = MediaFile()
     media_file.id = new_file.id
     if new_file.created_date:

kontor-api/src/db/repository/media/video.py

@@ -3,14 +3,15 @@ import uuid
 
 from sqlalchemy.orm import Session
 
-from kontor_model.db.models.media import MediaVideo
+from src.db.models.media import MediaVideo
+from src.webapps.media.forms import AddLinkForm
 
 
-def create_new_video(url: str, db: Session) -> MediaVideo:
-    print(url)
+def create_new_video(video: AddLinkForm, db: Session) -> MediaVideo:
+    print(video.url)
     media_video = MediaVideo()
     media_video.id = str(uuid.uuid4())
-    media_video.url = url
+    media_video.url = str(video.url)
     media_video.created_date = datetime.now()
     media_video.last_modified_date = datetime.now()
     media_video.review = True

kontor-api/src/db/repository/user.py

@@ -2,10 +2,10 @@ from datetime import datetime
 from typing import Optional
 import uuid
 from src.core.log_conf import logger
-from kontor_model.db.models.admin import Assignment, Profile
+from src.db.models.admin import Assignment, Profile
 from sqlalchemy.orm import Session
 
-from kontor_model.schema.user.profile import ProfileModel
+from src.schema.user.profile import ProfileModel
 
 
 def create_new_profile(new_profile: ProfileModel, db: Session) -> Profile:

kontor-api/src/main.py

@@ -10,7 +10,7 @@ from src.apis.version1.admin.login import login_router
 from src.core.config import settings
 from src.core.log_conf import logger
 from src.core.middleware import RequestLoggingMiddleware
-from kontor_model.db.models.base import Base
+from src.db.models.base import Base
 from src.db.session import engine
 from src.db.utils import check_db_connected, check_db_disconnected
 from src.webapps.base import api_router as web_app_router

kontor-api/src/schema/admin/mailaccount.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.admin import MailAccount
+from src.db.models.admin import MailAccount
 
 
 class MailAccountResponse(BaseModel):
@@ -24,11 +24,11 @@ def to_response(account: MailAccount) -> MailAccountResponse:
         created_date=account.created_date,
         last_modified_date=account.last_modified_date,
         version=account.version,
-        host=str(account.host),
+        host=account.host,
         port=account.port,
-        protocol=str(account.protocol),
-        user_name=str(account.user_name),
-        password=str(account.password),
-        start_tls=bool(account.start_tls),
+        protocol=account.protocol,
+        user_name=account.user_name,
+        password=account.password,
+        start_tls=account.start_tls,
     )
     return response

kontor-api/src/schema/bookshelf/article.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.bookshelf import Article
+from src.db.models.bookshelf import Article
 
 
 class ArticleResponse(BaseModel):
@@ -18,6 +18,6 @@ def to_response(article:  Article) -> ArticleResponse:
             created_date=article.created_date,
             last_modified_date=article.last_modified_date,
             version=article.version,
-            title=str(article.title)
+            title=article.title
     )
     return response

kontor-api/src/schema/bookshelf/articleauthor.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.bookshelf import ArticleAuthor
+from src.db.models.bookshelf import ArticleAuthor
 
 
 class ArticleAuthorResponse(BaseModel):
@@ -19,7 +19,7 @@ def to_response(articleauthor:  ArticleAuthor) -> ArticleAuthorResponse:
             created_date=articleauthor.created_date,
             last_modified_date=articleauthor.last_modified_date,
             version=articleauthor.version,
-            article_id=str(articleauthor.article_id),
-            author_id=str(articleauthor.author_id)
+            article_id=articleauthor.article_id,
+            author_id=articleauthor.author_id
     )
     return response

kontor-api/src/schema/bookshelf/author.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.bookshelf import Author
+from src.db.models.bookshelf import Author
 
 
 class AuthorResponse(BaseModel):
@@ -19,7 +19,7 @@ def to_response(author:  Author) -> AuthorResponse:
             created_date=author.created_date,
             last_modified_date=author.last_modified_date,
             version=author.version,
-            first_name=str(author.first_name),
-            last_name=str(author.last_name)
+            first_name=author.first_name,
+            last_name=author.last_name
     )
     return response

kontor-api/src/schema/bookshelf/book.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.bookshelf import Book
+from src.db.models.bookshelf import Book
 
 
 class BookResponse(BaseModel):
@@ -21,9 +21,9 @@ def to_response(book:  Book) -> BookResponse:
             created_date=book.created_date,
             last_modified_date=book.last_modified_date,
             version=book.version,
-            isbn=str(book.isbn),
-            title=str(book.title),
+            isbn=book.isbn,
+            title=book.title,
             year=book.year,
-            publisher_id=str(book.publisher_id)
+            publisher_id=book.publisher_id
     )
     return response

kontor-api/src/schema/bookshelf/bookauthor.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.bookshelf import BookAuthor
+from src.db.models.bookshelf import BookAuthor
 
 
 class BookAuthorResponse(BaseModel):
@@ -19,7 +19,7 @@ def to_response(bookauthor:  BookAuthor) -> BookAuthorResponse:
             created_date=bookauthor.created_date,
             last_modified_date=bookauthor.last_modified_date,
             version=bookauthor.version,
-            author_id=str(bookauthor.author_id),
-            book_id=str(bookauthor.book_id)
+            author_id=bookauthor.author_id,
+            book_id=bookauthor.book_id
     )
     return response

kontor-api/src/schema/bookshelf/publisher.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.bookshelf import BookshelfPublisher
+from src.db.models.bookshelf import BookshelfPublisher
 
 
 class PublisherResponse(BaseModel):
@@ -18,6 +18,6 @@ def to_response(publisher:  BookshelfPublisher) -> PublisherResponse:
             created_date=publisher.created_date,
             last_modified_date=publisher.last_modified_date,
             version=publisher.version,
-            name=str(publisher.name)
+            name=publisher.name
     )
     return response

kontor-api/src/schema/comics/artist.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.comic import Artist
+from src.db.models.comic import Artist
 
 
 class ArtistCreation(BaseModel):

kontor-api/src/schema/comics/artist_details.py

@@ -1,9 +1,9 @@
 from typing import List
 from pydantic import BaseModel
 
-from kontor_model.schema.comics.comic import ComicResponse
-from kontor_model.schema.comics.issue_details import IssueDetailsResponse
-from kontor_model.schema.comics.worktype import WorktypeResponse
+from src.schema.comics.comic import ComicResponse
+from src.schema.comics.issue_details import IssueDetailsResponse
+from src.schema.comics.worktype import WorktypeResponse
 
 
 class ArtistWorktypeComicResponse(BaseModel):

kontor-api/src/schema/comics/comic.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from typing import Optional
 from pydantic import BaseModel, AnyUrl
 
-from kontor_model.db.models.comic import Comic
+from src.db.models.comic import Comic
 
 
 class ComicResponse(BaseModel):
@@ -28,11 +28,11 @@ def comic_to_response(comic:  Comic) -> ComicResponse:
             created_date=comic.created_date,
             last_modified_date=comic.last_modified_date,
             version=comic.version,
-            title=str(comic.title),
-            publisher_id=str(comic.publisher_id),
-            current_order=bool(comic.current_order),
-            completed=bool(comic.completed),
-            weblink=str(comic.weblink)
+            title=comic.title,
+            publisher_id=comic.publisher_id,
+            current_order=comic.current_order,
+            completed=comic.completed,
+            weblink=comic.weblink
     )
     return response
 

kontor-api/src/schema/comics/comic_details.py

@@ -1,11 +1,11 @@
 from typing import List
 from pydantic import BaseModel
 
-from kontor_model.schema.comics.artist import ArtistResponse
-from kontor_model.schema.comics.issue import IssueResponse
-from kontor_model.schema.comics.publisher import PublisherResponse
-from kontor_model.schema.comics.volume import VolumeResponse
-from kontor_model.schema.comics.worktype import WorktypeResponse
+from src.schema.comics.artist import ArtistResponse
+from src.schema.comics.issue import IssueResponse
+from src.schema.comics.publisher import PublisherResponse
+from src.schema.comics.volume import VolumeResponse
+from src.schema.comics.worktype import WorktypeResponse
 
 
 class ComicWorktypeArtistResponse(BaseModel):

kontor-api/src/schema/comics/comicwork.py

@@ -6,7 +6,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.comic import ComicWork
+from src.db.models.comic import ComicWork
 
 
 class ComicWorkResponse(BaseModel):
@@ -25,8 +25,8 @@ def comicwork_to_response(comicwork: ComicWork) -> ComicWorkResponse:
         created_date=comicwork.created_date,
         last_modified_date=comicwork.last_modified_date,
         version=comicwork.version,
-        comic_id=str(comicwork.comic_id),
-        artist_id=str(comicwork.artist_id),
-        work_type_id=str(comicwork.work_type_id),
+        comic_id=comicwork.comic_id,
+        artist_id=comicwork.artist_id,
+        work_type_id=comicwork.work_type_id,
     )
     return response

kontor-api/src/schema/comics/issue.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.comic import Issue
+from src.db.models.comic import Issue
 
 
 class IssueResponse(BaseModel):
@@ -26,13 +26,13 @@ def issue_to_response(issue: Issue) -> IssueResponse:
         created_date=issue.created_date,
         last_modified_date=issue.last_modified_date,
         version=issue.version,
-        issue_number=str(issue.issue_number),
-        title=str(issue.title),
+        issue_number=issue.issue_number,
+        title=issue.title,
         published_on=issue.published_on,
-        in_stock=bool(issue.in_stock),
-        is_read=bool(issue.is_read),
-        comic_id=str(issue.comic_id),
-        volume_id=str(issue.volume_id),
-        story_arc_id=str(issue.story_arc_id)
+        in_stock=issue.in_stock,
+        is_read=issue.is_read,
+        comic_id=issue.comic_id,
+        volume_id=issue.volume_id,
+        story_arc_id=issue.story_arc_id
     )
     return response

kontor-api/src/schema/comics/issue_details.py

@@ -1,7 +1,7 @@
 from pydantic import BaseModel
 
-from kontor_model.schema.comics.comic import ComicResponse
-from kontor_model.schema.comics.volume import VolumeResponse
+from src.schema.comics.comic import ComicResponse
+from src.schema.comics.volume import VolumeResponse
 
 
 class IssueDetailsResponse(BaseModel):

kontor-api/src/schema/comics/issuework.py

@@ -6,7 +6,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.comic import IssueWork
+from src.db.models.comic import IssueWork
 
 
 class IssueWorkResponse(BaseModel):
@@ -25,8 +25,8 @@ def issuework_to_response(issuework: IssueWork) -> IssueWorkResponse:
         created_date=issuework.created_date,
         last_modified_date=issuework.last_modified_date,
         version=issuework.version,
-        issue_id=str(issuework.issue_id),
-        artist_id=str(issuework.artist_id),
-        work_type_id=str(issuework.work_type_id),
+        issue_id=issuework.issue_id,
+        artist_id=issuework.artist_id,
+        work_type_id=issuework.work_type_id,
     )
     return response

kontor-api/src/schema/comics/publisher.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.comic import Publisher
+from src.db.models.comic import Publisher
 
 
 class PublisherResponse(BaseModel):
@@ -22,8 +22,8 @@ def publisher_to_response(publisher:  Publisher) -> PublisherResponse:
             created_date=publisher.created_date,
             last_modified_date=publisher.last_modified_date,
             version=publisher.version,
-            name=str(publisher.name),
-            weblink=str(publisher.weblink),
+            name=publisher.name,
+            weblink=publisher.weblink,
             parent_publisher_id=publisher.parent_publisher_id
     )
     return response

kontor-api/src/schema/comics/publisher_details.py

@@ -2,8 +2,8 @@ from typing import List
 
 from pydantic import BaseModel
 
-from kontor_model.schema.comics.comic import ComicResponse
-from kontor_model.schema.comics.publisher import PublisherResponse
+from src.schema.comics.comic import ComicResponse
+from src.schema.comics.publisher import PublisherResponse
 
 
 class PublisherDetailsResponse(BaseModel):

kontor-api/src/schema/comics/storyarc.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.comic import StoryArc
+from src.db.models.comic import StoryArc
 
 class StoryArcResponse(BaseModel):
     id: str
@@ -23,8 +23,8 @@ def storyarc_to_response(storyarc: StoryArc) -> StoryArcResponse:
         created_date=storyarc.created_date,
         last_modified_date=storyarc.last_modified_date,
         version=storyarc.version,
-        name=str(storyarc.name),
-        comic_id=str(storyarc.comic_id),
-        volume_id=str(storyarc.volume_id)
+        name=storyarc.name,
+        comic_id=storyarc.comic_id,
+        volume_id=storyarc.volume_id
     )
     return response

kontor-api/src/schema/comics/volume.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.comic import Volume
+from src.db.models.comic import Volume
 
 
 class VolumeResponse(BaseModel):
@@ -19,7 +19,7 @@ def volume_to_response(volume: Volume) -> VolumeResponse:
         created_date=volume.created_date,
         last_modified_date=volume.last_modified_date,
         version=volume.version,
-        name=str(volume.name),
-        comic_id=str(volume.comic_id)
+        name=volume.name,
+        comic_id=volume.comic_id
     )
     return response

kontor-api/src/schema/comics/worktype.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.comic import WorkType
+from src.db.models.comic import WorkType
 
 class AddWorkType(BaseModel):
     worktype: str
@@ -21,6 +21,6 @@ def worktype_to_response(worktype: WorkType) -> WorktypeResponse:
         created_date=worktype.created_date,
         last_modified_date=worktype.last_modified_date,
         version=worktype.version,
-        name=str(worktype.name)
+        name=worktype.name
     )
     return response

kontor-api/src/schema/media/actor.py

@@ -2,7 +2,7 @@ from datetime import datetime
 from typing import Optional
 from pydantic import BaseModel
 
-from kontor_model.db.models.media import MediaActor
+from src.db.models.media import MediaActor
 
 
 class MediaActorResponse(BaseModel):
@@ -19,8 +19,8 @@ def actor_to_response(actor: MediaActor) -> MediaActorResponse:
         created_date=actor.created_date,
         last_modified_date=actor.last_modified_date,
         version=actor.version,
-        name=str(actor.name),
-        url=str(actor.url)        
+        name=actor.name,
+        url=actor.url        
     )
     return response
 

kontor-api/src/schema/media/actorfile.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import Optional
 
-from kontor_model.db.models.media import MediaActorFile
+from src.db.models.media import MediaActorFile
 from pydantic import BaseModel
 
 
@@ -19,8 +19,8 @@ def actorfile_to_response(actorfile:  MediaActorFile) -> MediaActorFileResponse:
             created_date=actorfile.created_date,
             last_modified_date=actorfile.last_modified_date,
             version=actorfile.version,
-            media_actor_id=str(actorfile.media_actor_id),
-            media_file_id=str(actorfile.media_file_id)
+            media_actor_id=actorfile.media_actor_id,
+            media_file_id=actorfile.media_file_id
     )
     return response
 

kontor-api/src/schema/media/article.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.media import MediaArticle
+from src.db.models.media import MediaArticle
 
 class MediaArticleResponse(BaseModel):
     id: str
@@ -23,8 +23,8 @@ def to_response(video: MediaArticle) -> MediaArticleResponse:
         created_date=video.created_date,
         last_modified_date=video.last_modified_date,
         version=video.version,
-        review=bool(video.review),
-        title=str(video.title),
-        url=str(video.url),
+        review=video.review,
+        title=video.title,
+        url=video.url,
     )
     return response

kontor-api/src/schema/media/file.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 from typing import Optional
 
-from kontor_model.db.models.media import MediaFile
+from src.db.models.media import MediaFile
 from pydantic import BaseModel
 
 

kontor-api/src/schema/media/video.py

@@ -3,7 +3,7 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.media import MediaVideo
+from src.db.models.media import MediaVideo
 
 class MediaVideoResponse(BaseModel):
     id: str
@@ -27,12 +27,12 @@ def video_to_response(video: MediaVideo) -> MediaVideoResponse:
         created_date=video.created_date,
         last_modified_date=video.last_modified_date,
         version=video.version,
-        cloud_link=str(video.cloud_link),
-        file_name=str(video.file_name),
-        path=str(video.path),
-        review=bool(video.review),
-        title=str(video.title),
-        url=str(video.url),
-        should_download=bool(video.should_download)
+        cloud_link=video.cloud_link,
+        file_name=video.file_name,
+        path=video.path,
+        review=video.review,
+        title=video.title,
+        url=video.url,
+        should_download=video.should_download
     )
     return response

kontor-api/src/schema/tysc/card.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.tysc import Card
+from src.db.models.tysc import Card
 
 
 class CardResponse(BaseModel):
@@ -24,8 +24,8 @@ def to_response(card: Card) -> CardResponse:
             version=card.version,
             card_number=card.card_number,
             year=card.year,
-            card_set_id=str(card.card_set_id),
-            rooster_id=str(card.rooster_id),
-            vendor_id=str(card.vendor_id)
+            card_set_id=card.card_set_id,
+            rooster_id=card.rooster_id,
+            vendor_id=card.vendor_id
     )
     return response

kontor-api/src/schema/tysc/cardset.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.tysc import CardSet
+from src.db.models.tysc import CardSet
 
 
 class CardSetResponse(BaseModel):
@@ -22,9 +22,9 @@ def to_response(cardset: CardSet) -> CardSetResponse:
             created_date=cardset.created_date,
             last_modified_date=cardset.last_modified_date,
             version=cardset.version,
-            name=str(cardset.name),
-            parallel_set=bool(cardset.parallel_set),
-            insert_set=bool(cardset.insert_set),
-            vendor_id=str(cardset.vendor_id)
+            name=cardset.name,
+            parallel_set=cardset.parallel_set,
+            insert_set=cardset.insert_set,
+            vendor_id=cardset.vendor_id
     )
     return response

kontor-api/src/schema/tysc/fieldposition.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.tysc import FieldPosition
+from src.db.models.tysc import FieldPosition
 
 
 class FieldPositionResponse(BaseModel):
@@ -21,8 +21,8 @@ def to_response(fieldposition: FieldPosition) -> FieldPositionResponse:
         created_date=fieldposition.created_date,
         last_modified_date=fieldposition.last_modified_date,
         version=fieldposition.version,
-        name=str(fieldposition.name),
-        short_name=str(fieldposition.short_name),
-        sport_id=str(fieldposition.sport_id)
+        name=fieldposition.name,
+        short_name=fieldposition.short_name,
+        sport_id=fieldposition.sport_id
     )
     return response

kontor-api/src/schema/tysc/player.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.tysc import Player
+from src.db.models.tysc import Player
 
 
 class PlayerResponse(BaseModel):
@@ -19,7 +19,7 @@ def to_response(player: Player) -> PlayerResponse:
             created_date=player.created_date,
             last_modified_date=player.last_modified_date,
             version=player.version,
-            first_name=str(player.first_name),
-            last_name=str(player.last_name)
+            first_name=player.first_name,
+            last_name=player.last_name
     )
     return response

kontor-api/src/schema/tysc/rooster.py

@@ -2,7 +2,7 @@ from datetime import datetime
 
 from pydantic import BaseModel
 
-from kontor_model.db.models.tysc import Rooster
+from src.db.models.tysc import Rooster
 
 
 class RoosterResponse(BaseModel):
@@ -29,8 +29,8 @@ def to_response(rooster: Rooster) -> RoosterResponse:
         last_modified_date=rooster.last_modified_date,
         version=rooster.version,
         year=rooster.year,
-        team_id=str(rooster.team_id),
-        player_id=str(rooster.player_id),
-        position_id=str(rooster.position_id)
+        team_id=rooster.team_id,
+        player_id=rooster.player_id,
+        position_id=rooster.position_id
     )
     return response