add publishing of kontor-model

update kontor-api
update Vaadin to 25.2.6 (#95 )
2026-08-26 18:33:35 +02:00 · 2026-08-25 17:45:03 +02:00 · 2026-08-25 14:15:18 +00:00 · 2026-08-25 11:11:51 +02:00 · 2026-08-25 09:43:49 +02:00 · 2026-08-25 06:01:17 +00:00
1047 changed files with 40117 additions and 23717 deletions
@@ -0,0 +1,19 @@
 name: Gitea Actions Demo
 run-name: ${{ gitea.actor }} ist testing out Gitea Actions
 on: [push]
 jobs:
  Explore-Gitea-Actions:
    runs-on: inky
    steps:
      - run: echo "The job was automatically triggered by a ${{ gitea.event_name }} event."
      - run: echo "This job is now running on a ${{ runner.os }} server hosted by Gitea!"
      - run: echo "The name of your branch is ${{ gitea.ref }} and your repository is ${{ gitea.repository }}."
      - name: Check out repository code
        uses: actions/checkout@v4
      - run: echo "The ${{ gitea.repository }} repository has been cloned to the runner."
      - run: echo "The workflow is now ready to test your code on the runner."
      - name: List files in the directory
        run: |
          ls ${{ gitea.workspace }}
      - run: echo "The job's status is ${{ job.status }}."
@@ -6,3 +6,9 @@ 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
@@ -0,0 +1,12 @@
 # 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
@@ -0,0 +1,15 @@
 ### STAGE 1: Build ###
 FROM docker.io/node:22-alpine AS build
 WORKDIR /app
 COPY package.json package-lock.json ./
 RUN npm install
 COPY . .
 RUN npm run build
 ### STAGE 2: Run ###
 FROM docker.io/library/nginx:stable-alpine
 COPY nginx.conf /etc/nginx/conf.d/default.conf
 COPY --from=build /app/dist/kontor-angular/browser /usr/share/nginx/html
 EXPOSE 80
 CMD ["nginx", "-g", "daemon off;"]
@@ -1,14 +0,0 @@
 ### STAGE 1: Build ###
 FROM node:22.15-alpine AS build
 WORKDIR /app
 COPY package.json package-lock.json ./
 RUN npm install
 COPY . .
 RUN npm run build
 ### STAGE 2: Run ###
 FROM nginx:1.17.1-alpine
 COPY nginx.conf /etc/nginx/conf.d/default.conf
 COPY --from=build /app/dist/kontor-angular/browser /usr/share/nginx/html
 EXPOSE 80
@@ -1,4 +1,5 @@
 server {
    listen 8800;
    # Root-Verzeichnis für den Server setzen (wir kopieren unsere Anwendung hierher)
    root /usr/share/nginx/html;
@@ -14,7 +14,6 @@ ENV PATH="/root/.local/bin:${PATH}"
 WORKDIR /app
 COPY ./pyproject.toml .
 RUN uv sync
 # ------------------------------- Production Stage ------------------------------ ##
@@ -1,6 +1,6 @@
 [project]
 name = "kontor-api"
-version = "0.1.0"
+version = "0.4.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -24,9 +24,21 @@ 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"
@@ -1,12 +1,245 @@
-from fastapi import APIRouter
+"""
 add router for different parts (like comics, tysc, media)
 """
-from src.apis.version1 import comic, mediaactor, mediafile, mediaactorfile, tysc, admin, user
+from fastapi import APIRouter, Depends
 from src.apis.version1.admin import mailaccount
 from src.apis.version1.comics import (
    artist,
    publisher,
    comic,
    issue,
    worktype,
    volume,
    storyarc,
    comicwork,
    issuework,
 )
 from src.apis.version1.media import (
    actor,
    file,
    lofi,
    mediaactorfile,
    mediavideo,
    mediaarticle,
 )
 from src.apis.version1.tysc import (
    card,
    cardset,
    fieldposition,
    player,
    rooster,
    sport,
    team,
    vendor,
 )
 from src.core.security import get_current_user_from_token
-api_router =  APIRouter(prefix="/api")
+from src.apis.version1.user import assignment, permission, profile, token
-api_router.include_router(comic.router, prefix="/comics", tags=["comics"])
+from src.apis.version1.bookshelf import article, bookshelf_publisher, book, author, articleauthor, bookauthor
-api_router.include_router(mediafile.router, prefix="/media", tags=["media"])
+
-api_router.include_router(mediaactor.router, prefix="/media", tags=["media"])
+api_router = APIRouter(prefix="/api")
-api_router.include_router(mediaactorfile.router, prefix="/media", tags=["media"])
+api_router.include_router(
-api_router.include_router(tysc.router, prefix="/tysc", tags=["tysc"])
+    comic.router,
-api_router.include_router(admin.router, prefix="/login", tags=["login"])
+    prefix="/comics",
-api_router.include_router(user.router, prefix="/user", tags=["user"])
+    tags=["comics"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    publisher.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(
    worktype.router,
    prefix="/comics",
    tags=["comics"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    volume.router,
    prefix="/comics",
    tags=["comics"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    storyarc.router,
    prefix="/comics",
    tags=["comics"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    comicwork.router,
    prefix="/comics",
    tags=["comics"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    issuework.router,
    prefix="/comics",
    tags=["comics"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    file.router,
    prefix="/media",
    tags=["media"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    mediavideo.router,
    prefix="/media",
    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",
    tags=["media"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    actor.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(
    bookshelf_publisher.router,
    prefix="/bookshelf",
    tags=["bookshelf"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    book.router,
    prefix="/bookshelf",
    tags=["bookshelf"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    author.router,
    prefix="/bookshelf",
    tags=["bookshelf"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    articleauthor.router,
    prefix="/bookshelf",
    tags=["bookshelf"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    bookauthor.router,
    prefix="/bookshelf",
    tags=["bookshelf"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    profile.router,
    prefix="/user",
    tags=["user"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    token.router,
    prefix="/user",
    tags=["user"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    permission.router,
    prefix="/user",
    tags=["user"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    assignment.router,
    prefix="/user",
    tags=["user"],
    dependencies=[Depends(get_current_user_from_token)],
 )
 api_router.include_router(
    mailaccount.router,
    prefix="/admin",
    tags=["admin"],
    dependencies=[Depends(get_current_user_from_token)],
 )
@@ -1,52 +0,0 @@
 from datetime import timedelta
 from typing import Annotated
 from fastapi import APIRouter, Body, HTTPException, status, Depends, Response
 from fastapi.security import OAuth2PasswordRequestForm
 from src.core.config import settings
 from src.core.security import create_access_token, authenticate_user, get_current_active_user
 from src.db.models.admin import Profile
 from src.schema.admin import Token, ProfileModel
 from src.webapps.auth.forms import LoginForm
 router = APIRouter()
@router.post("/token")
 def login_for_access_token(form_data: Annotated[OAuth2PasswordRequestForm, Depends()]) -> Token:
    user = authenticate_user(form_data.username, form_data.password)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
    access_token = create_access_token(
        data={"sub": user.email, "scope": " ".join(form_data.scopes)}, expires_delta=access_token_expires
    )
    return Token(access_token=access_token, token_type="bearer")
 # @router.post("/token-cookie", response_model=Token)
 def login_for_token_cookie(response: Response, form_data: LoginForm = Depends()):
    user = authenticate_user(form_data.username, form_data.password) # type: ignore
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
        )
    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
    access_token = create_access_token(
        data={"sub": user.email}, expires_delta=access_token_expires
    )
    response.set_cookie(
        key="access_token", value=f"Bearer {access_token}", httponly=True
    )
    return {"access_token": access_token, "token_type": "bearer"}
@router.get("/profile", response_model=ProfileModel)
 async def read_profile(current_user: Annotated[Profile, Depends(get_current_active_user)]):
    return current_user
@@ -0,0 +1,74 @@
 from datetime import timedelta
 from fastapi import APIRouter, Depends, HTTPException, Response, status
 from fastapi.security import OAuth2PasswordRequestForm
 from src.core.config import settings
 from src.core.log_conf import logger
 from src.core.security import (
    authenticate_user_by_email,
    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.webapps.auth.forms import LoginForm
 login_router = APIRouter()
@login_router.post(
    "/login",
    tags=["login"],
    summary="Login and get token",
    response_description="Return HTTP status code 200 (OK)",
    status_code=status.HTTP_200_OK,
 )
 def login(request: LoginRequest) -> Token:
    logger.info("login with %s", request.email)
    user = authenticate_user_by_email(str(request.email), str(request.password))
    scopes = ["admin", "read"]
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
    access_token = create_access_token(
        data={"sub": user.email, "scope": " ".join(scopes)},
        expires_delta=access_token_expires,
    )
    return Token(access_token=access_token, token_type="bearer")
@login_router.post("/token", tags=["login"], summary="Login for access token")
 # async def login_for_access_token(form_data: Annotated[OAuth2PasswordRequestForm, Depends()]) -> Token:
 async def login_for_access_token(
    form_data: OAuth2PasswordRequestForm = Depends(),
 ) -> Token:
    user = authenticate_user_by_username(form_data.username, form_data.password)
    if not user:
        raise HTTPException(status_code=400, detail="Incorrect username or password")
    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
    access_token = create_access_token(
        data={"sub": user.user_name, "scope": " ".join(form_data.scopes)},
        expires_delta=access_token_expires,
    )
    return Token(access_token=access_token, token_type="bearer")
 def login_for_token_cookie(response: Response, form_data: LoginForm = Depends()):
    user = authenticate_user_by_email(str(form_data.username), str(form_data.password))
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
        )
    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
    access_token = create_access_token(
        data={"sub": user.email}, expires_delta=access_token_expires
    )
    response.set_cookie(
        key="access_token", value=f"Bearer {access_token}", httponly=True
    )
    return {"access_token": access_token, "token_type": "bearer"}
@@ -0,0 +1,32 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.admin import MailAccount
 from src.db.session import SessionDep
 from kontor_model.schema.admin.mailaccount import MailAccountResponse, to_response
 router = APIRouter()
@router.get("/mailaccounts", response_model=List[MailAccountResponse])
 def get_all_mailaccounts(db: SessionDep) -> List[MailAccountResponse]:
    """
    return all MailAccounts as JSON.
    """
    results: List[MailAccountResponse] = []
    mailaccounts = db.query(MailAccount).all()
    for mailaccount in mailaccounts:
        response = to_response(mailaccount)
        results.append(response)
    return results
@router.get("/mailaccounts/{mailaccount_id}", response_model=MailAccountResponse)
 def get_mailaccount(mailaccount_id: str, db: SessionDep) -> MailAccountResponse:
    """
    return MailAccounts by id.
    """
    mailaccount = db.get(MailAccount, mailaccount_id)
    if mailaccount is None:
        raise HTTPException(status_code=409, detail="Mailaccount could not be found")
    response = to_response(mailaccount)
    return response
@@ -0,0 +1,20 @@
 from typing import List
 from fastapi import APIRouter
 from kontor_model.db.models.bookshelf import Article
 from src.db.session import SessionDep
 from kontor_model.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
@@ -0,0 +1,19 @@
 from typing import List
 from fastapi import APIRouter
 from kontor_model.db.models.bookshelf import ArticleAuthor
 from src.db.session import SessionDep
 from kontor_model.schema.bookshelf.articleauthor import ArticleAuthorResponse, to_response
 router = APIRouter()
@router.get("/articleauthors", response_model=List[ArticleAuthorResponse])
 def get_all_artists(db: SessionDep) -> List[ArticleAuthorResponse]:
    results: List[ArticleAuthorResponse] = []
    articleauthors = db.query(ArticleAuthor).all()
    for articleauthor in articleauthors:
        response = to_response(articleauthor)
        results.append(response)
    return results
@@ -0,0 +1,26 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.bookshelf import Author
 from src.db.session import SessionDep
 from kontor_model.schema.bookshelf.author import AuthorResponse, to_response
 router = APIRouter()
@router.get("/authors", response_model=List[AuthorResponse])
 def get_all_authors(db: SessionDep) -> List[AuthorResponse]:
    results: List[AuthorResponse] = []
    authors = db.query(Author).all()
    for author in authors:
        response = to_response(author)
        results.append(response)
    return results
@router.get("/authors/{author_id}", response_model=AuthorResponse)
 def get_author(author_id: str, db: SessionDep) -> AuthorResponse:
    author = db.get(Author, author_id)
    if author is None:
        raise HTTPException(status_code=404, detail="Author could not be found")
    response = to_response(author)
    return response
@@ -0,0 +1,19 @@
 from typing import List
 from fastapi import APIRouter
 from kontor_model.db.models.bookshelf import Book
 from src.db.session import SessionDep
 from kontor_model.schema.bookshelf.book import BookResponse, to_response
 router = APIRouter()
@router.get("/books", response_model=List[BookResponse])
 def get_all_artists(db: SessionDep) -> List[BookResponse]:
    results: List[BookResponse] = []
    books = db.query(Book).all()
    for book in books:
        response = to_response(book)
        results.append(response)
    return results
@@ -0,0 +1,19 @@
 from typing import List
 from fastapi import APIRouter
 from kontor_model.db.models.bookshelf import BookAuthor
 from src.db.session import SessionDep
 from kontor_model.schema.bookshelf.bookauthor import BookAuthorResponse, to_response
 router = APIRouter()
@router.get("/bookauthors", response_model=List[BookAuthorResponse])
 def get_all_artists(db: SessionDep) -> List[BookAuthorResponse]:
    results: List[BookAuthorResponse] = []
    bookauthors = db.query(BookAuthor).all()
    for bookauthor in bookauthors:
        response = to_response(bookauthor)
        results.append(response)
    return results
@@ -0,0 +1,19 @@
 from typing import List
 from fastapi import APIRouter
 from kontor_model.db.models.bookshelf import BookshelfPublisher
 from src.db.session import SessionDep
 from kontor_model.schema.bookshelf.publisher import PublisherResponse, to_response
 router = APIRouter()
@router.get("/publishers", response_model=List[PublisherResponse])
 def get_all_artists(db: SessionDep) -> List[PublisherResponse]:
    results: List[PublisherResponse] = []
    publishers = db.query(BookshelfPublisher).all()
    for publisher in publishers:
        response = to_response(publisher)
        results.append(response)
    return results
@@ -1,103 +0,0 @@
 from typing import List
 from fastapi import APIRouter, HTTPException, status
 from src.core.log_conf import logger
 from src.db.models.comic import Artist, Comic, Issue, Publisher
 from src.db.repository.comics.artist import get_artist_details
 from src.db.repository.comics.comic import (
    get_comic_details,
    get_issue_details,
    get_short_info,
    list_comics,
 )
 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
 router = APIRouter()
@router.get("/comics")
 def get_all_comics(db: SessionDep) -> List[ComicResponse]: # type: ignore
    results: List[ComicResponse] = []
    comics = list_comics(db)
    for comic in comics:
        response = get_short_info(comic)
        results.append(response)
    return results
@router.get("/comics/{comic_id}", response_model=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")
    logger.info(f"create ComicDetailsResponse for {comic}")
    response: ComicDetailsResponse = get_comic_details(comic)
    logger.info(f"ComicDetailsResponse: {response}")
    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
    results: List[PublisherResponse] = []
    publishers = db.query(Publisher).all()
    for publisher in publishers:
        results.append(PublisherResponse(id=publisher.id, name=str(publisher.name)))
    return results
@router.get("/publishers/{publisher_id}", response_model=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")
    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
@@ -0,0 +1,53 @@
 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.session import SessionDep
 from kontor_model.schema.comics.artist import ArtistCreation, ArtistResponse, artist_to_response
 from kontor_model.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:
        response = artist_to_response(artist)
        results.append(response)
    return results
@router.get("/artists/{artist_id}", response_model=ArtistResponse)
 def get_artist(artist_id: str, db: SessionDep) -> ArtistResponse:
    artist = db.get(Artist, artist_id)
    if artist is None:
        raise HTTPException(status_code=404, detail="Artist could not be found")
    response: ArtistResponse = artist_to_response(artist)
    return response
@router.get("/artists/details/{artist_id}", response_model=ArtistDetailResponse)
 def get_artist_details_by_id(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 = artist_to_response(artist)
    return response
@@ -0,0 +1,44 @@
 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 (
    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
 router = APIRouter()
@router.get("/comics")
 def get_all_comics(db: SessionDep) -> List[ComicResponse]:
    results: List[ComicResponse] = []
    comics = db.query(Comic).all()
    for comic in comics:
        response = comic_to_response(comic)
        results.append(response)
    return results
@router.get("/comics/{comic_id}", response_model=ComicResponse)
 def get_comic(comic_id: str, db: SessionDep) -> ComicResponse:
    comic = db.get(Comic, comic_id)
    if comic is None:
        raise HTTPException(status_code=404, detail="Comic could not be found")
    response: ComicResponse = comic_to_response(comic)
    return response
@router.get("/comics/details/{comic_id}", response_model=ComicDetailsResponse)
 def get_comic_details_by_id(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")
    logger.info(f"create ComicDetailsResponse for {comic}")
    response: ComicDetailsResponse = get_comic_details(comic)
    logger.info(f"ComicDetailsResponse: {response}")
    return response
@@ -0,0 +1,27 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.comic import ComicWork
 from src.db.session import SessionDep
 from kontor_model.schema.comics.comicwork import ComicWorkResponse, comicwork_to_response
 router = APIRouter()
@router.get("/comicworks", response_model=List[ComicWorkResponse])
 def get_comicworks(db: SessionDep) -> List[ComicWorkResponse]:
    results: List[ComicWorkResponse] = []
    worktypes = db.query(ComicWork).all()
    for worktype in worktypes:
        response = comicwork_to_response(worktype)
        results.append(response)
    return results
@router.get("/comicworks/{comicwork_id}", response_model=ComicWorkResponse)
 def get_comicwork(comicwork_id: str, db: SessionDep) -> ComicWorkResponse:
    worktype = db.get(ComicWork, comicwork_id)
    if worktype is None:
        raise HTTPException(status_code=404, detail="Comicwork could not be found")
    response = comicwork_to_response(worktype)
    return response
@@ -0,0 +1,27 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.comic import Issue
 from src.db.session import SessionDep
 from kontor_model.schema.comics.issue import IssueResponse, issue_to_response
 router = APIRouter()
@router.get("/issues", response_model=List[IssueResponse])
 def get_issues(db: SessionDep) -> List[IssueResponse]:
    results: List[IssueResponse] = []
    issues = db.query(Issue).all()
    for issue in issues:
        response = issue_to_response(issue)
        results.append(response)
    return results
@router.get("/issues/{issue_id}", response_model=IssueResponse)
 def get_issue(issue_id: str, db: SessionDep) -> IssueResponse:
    issue = db.get(Issue, issue_id)
    if issue is None:
        raise HTTPException(status_code=404, detail="Issue could not be found")
    response = issue_to_response(issue)
    return response
@@ -0,0 +1,27 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.comic import IssueWork
 from src.db.session import SessionDep
 from kontor_model.schema.comics.issuework import IssueWorkResponse, issuework_to_response
 router = APIRouter()
@router.get("/issueworks", response_model=List[IssueWorkResponse])
 def get_issueworks(db: SessionDep) -> List[IssueWorkResponse]:
    results: List[IssueWorkResponse] = []
    worktypes = db.query(IssueWork).all()
    for worktype in worktypes:
        response = issuework_to_response(worktype)
        results.append(response)
    return results
@router.get("/issueworks/{issuework_id}", response_model=IssueWorkResponse)
 def get_issuework(issuework_id: str, db: SessionDep) -> IssueWorkResponse:
    worktype = db.get(IssueWork, issuework_id)
    if worktype is None:
        raise HTTPException(status_code=404, detail="Issuework could not be found")
    response = issuework_to_response(worktype)
    return response
@@ -0,0 +1,37 @@
 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.session import SessionDep
 from kontor_model.schema.comics.publisher import PublisherResponse, publisher_to_response
 from kontor_model.schema.comics.publisher_details import PublisherDetailsResponse
 router = APIRouter()
@router.get("/publishers", response_model=List[PublisherResponse])
 def get_all_publishers(db: SessionDep) -> List[PublisherResponse]:
    results: List[PublisherResponse] = []
    publishers = db.query(Publisher).all()
    for publisher in publishers:
        response: PublisherResponse = publisher_to_response(publisher)
        results.append(response)
    return results
@router.get("/publishers/{publisher_id}", response_model=PublisherResponse)
 def get_publisher(publisher_id: str, db: SessionDep) -> PublisherResponse:
    publisher = db.get(Publisher, publisher_id)
    if publisher is None:
        raise HTTPException(status_code=404, detail="Publisher could not be found")
    response: PublisherResponse = publisher_to_response(publisher)
    return response
@router.get("/publishers/details/{publisher_id}", response_model=PublisherDetailsResponse)
 def get_publisher_details_by_id(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
@@ -0,0 +1,26 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.comic import StoryArc
 from src.db.session import SessionDep
 from kontor_model.schema.comics.storyarc import StoryArcResponse, storyarc_to_response
 router = APIRouter()
@router.get("/storyarcs", response_model=List[StoryArcResponse])
 def get_storyarcs(db: SessionDep) -> List[StoryArcResponse]:
    results: List[StoryArcResponse] = []
    storyarcs = db.query(StoryArc).all()
    for storyarc in storyarcs:
        response = storyarc_to_response(storyarc)
        results.append(response)
    return results
@router.get("/storyarcs/{storyarc_id}", response_model=StoryArcResponse)
 def get_storyarc(story_arc_id: str, db: SessionDep) -> StoryArcResponse:
    storyarc = db.get(StoryArc, story_arc_id)
    if storyarc is None:
        raise HTTPException(status_code=404, detail="Storyarc could not be found")
    response = storyarc_to_response(storyarc)
    return response
@@ -0,0 +1,26 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.comic import Volume
 from src.db.session import SessionDep
 from kontor_model.schema.comics.volume import VolumeResponse, volume_to_response
 router = APIRouter()
@router.get("/volumes", response_model=List[VolumeResponse])
 def volumes(db: SessionDep) -> List[VolumeResponse]:
    results: List[VolumeResponse] = []
    worktypes = db.query(Volume).all()
    for worktype in worktypes:
        response = volume_to_response(worktype)
        results.append(response)
    return results
@router.get("/volumes/{volume_id}", response_model=VolumeResponse)
 def get_volume(volume_id: str, db: SessionDep) -> VolumeResponse:
    worktype = db.get(Volume, volume_id)
    if worktype is None:
        raise HTTPException(status_code=404, detail="Volume could not be found")
    response = volume_to_response(worktype)
    return response
@@ -0,0 +1,27 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.comic import WorkType
 from src.db.session import SessionDep
 from kontor_model.schema.comics.worktype import WorktypeResponse, worktype_to_response
 router = APIRouter()
@router.get("/worktypes", response_model=List[WorktypeResponse])
 def get_issues(db: SessionDep) -> List[WorktypeResponse]:
    results: List[WorktypeResponse] = []
    worktypes = db.query(WorkType).all()
    for worktype in worktypes:
        response = worktype_to_response(worktype)
        results.append(response)
    return results
@router.get("/worktypes/{worktype_id}", response_model=WorktypeResponse)
 def get_issue(worktype_id: str, db: SessionDep) -> WorktypeResponse:
    worktype = db.get(WorkType, worktype_id)
    if worktype is None:
        raise HTTPException(status_code=404, detail="Worktype could not be found")
    response = worktype_to_response(worktype)
    return response
@@ -1,6 +1,6 @@
 from fastapi import APIRouter, status
-from src.schema.admin import HealthCheck
+from kontor_model.schema.admin.healthcheck import HealthCheck
 health_router = APIRouter()
@@ -1,41 +0,0 @@
 from datetime import timedelta
 from fastapi import APIRouter, HTTPException, status
 from pydantic import BaseModel
 from src.core.config import settings
 from src.core.log_conf import logger
 from src.core.security import authenticate_user, create_access_token
 from src.schema.admin import Token
 login_router = APIRouter()
 class LoginRequest(BaseModel):
    email: str | None = None
    password: str | None = None
@login_router.post(
    "/login",
    tags=["login"],
    summary="Login and get token",
    response_description="Return HTTP status code 200 (OK)",
    status_code=status.HTTP_200_OK,
 )
 def login(request: LoginRequest) -> Token:
    logger.info(f"login with {request.email}")
    user = authenticate_user(request.email, request.password)
    scopes = ["admin", "read"]
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
    access_token = create_access_token(
        data={"sub": user.email, "scope": " ".join(scopes)},
        expires_delta=access_token_expires,
    )
    return Token(access_token=access_token, token_type="bearer")
@@ -0,0 +1,45 @@
 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.session import SessionDep
 from kontor_model.schema.media.actor import MediaActorModel, MediaActorResponse, actor_to_response
 from kontor_model.db.models.media import MediaActor
 router = APIRouter()
@router.get("/actors", response_model=List[MediaActorResponse])
 def get_all_actors(db: SessionDep) -> List[MediaActorResponse]:
    results: list[MediaActorResponse] = []
    actors = db.query(MediaActor).all()
    for mediaactor in actors:
        response =  actor_to_response(mediaactor)
        results.append(response)
    return results
@router.get("/actors/{actor_id}", response_model=MediaActorResponse)
 def get_actor(actor_id: str, db: SessionDep) -> MediaActorResponse:
    media_actor = db.get(MediaActor, actor_id)
    if not media_actor:
        raise HTTPException(status_code=404, detail="MediaActor could not be found")
    response = actor_to_response(media_actor)
    return response
@router.delete("/actors/{actor_id}", status_code=status.HTTP_204_NO_CONTENT)
 def delete_actor(actor_id: str, db: SessionDep):
    media_actor = db.get(MediaActor, actor_id)
    if not media_actor:
        raise HTTPException(status_code=404, detail="MediaActor could not be found")
    logger.info(f"delete MediaActor: {actor_id}")
    delete_mediaactor(db, media_actor.id)
@router.post("/actors", status_code=status.HTTP_201_CREATED)
 def add_actor(new_actor: MediaActorModel, db: SessionDep) -> MediaActorResponse:
    logger.info(f"add actor {new_actor.url}")
    try:
        mediaActor: MediaActor = import_mediaactor(db, new_actor)
    except Exception as exception:
        raise HTTPException(status_code=409, detail=f"Link duplicate: {exception}")
    response = actor_to_response(mediaActor)
    return response
@@ -0,0 +1,163 @@
 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 (
    create_new_mediaactorfile,
    delete_mediaactorfile,
 )
 from kontor_model.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 (
    MediaFileModel,
    MediaFileResponse,
    file_to_response,
    file_to_model,
 )
 from kontor_model.db.models.media import MediaFile
 router = APIRouter()
@router.get("/update-titles")
 def update_titles(db: SessionDep) -> List[MediaFileResponse]:
    """
    Update title for given MediaFile.
    """
    results: list[MediaFileResponse] = []
    files = db.query(MediaFile).filter(MediaFile.review.is_(True)).all()
    for mediafile in files:
        mediafile.update_title()
        db.add(mediafile)
        response = file_to_response(mediafile)
        results.append(response)
    db.commit()
    return results
@router.get("/files", response_model=List[MediaFileResponse])
 def get_all_files(
    db: SessionDep, review: bool = False, download: bool = False
 ) -> List[MediaFileResponse]:
    """
    Get all MediaFiles.
    """
    results: List[MediaFileResponse] = []
    files: List[MediaFile]
    if review:
        files = db.query(MediaFile).filter(MediaFile.review.is_(True)).all()
    elif download:
        files = db.query(MediaFile).filter(MediaFile.should_download.is_(True)).all()
    else:
        files = db.query(MediaFile).all()
    for mediafile in files:
        response = file_to_response(mediafile)
        results.append(response)
    return results
@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.
    """
    mediafile = db.get(MediaFile, file_id)
    if not mediafile:
        raise HTTPException(status_code=404, detail="MediaFile could not be found")
    response = file_to_response(mediafile)
    return response
@router.delete("/files/{file_id}", status_code=status.HTTP_204_NO_CONTENT)
 def delete_file(file_id: str, db: SessionDep):
    """
    Delete MediaFile by given id.
    """
    mediafile = db.get(MediaFile, file_id)
    if not mediafile:
        raise HTTPException(status_code=404, detail="MediaFile could not be found")
    logger.info("delete MediaFile: %s", file_id)
    actor_files = mediafile.media_actor_files
    logger.info("MediaActorFiles links %s", len(actor_files))
    if len(actor_files) > 0:
        logger.info("delete MediaActor relations first")
        for actor_file in actor_files:
            delete_mediaactorfile(db, actor_file.id)
    delete_mediafile(db, mediafile.id)
@router.get("/files/{file_id}/actors", response_model=list[MediaActorResponse])
 def get_file_actors(file_id: str, db: SessionDep) -> list[MediaActorResponse]:
    """
    Get list of Actors for given MediaFile.
    """
    mediafile = db.get(MediaFile, file_id)
    if not mediafile:
        raise HTTPException(status_code=404, detail="MediaFile could not be found")
    actor_files = mediafile.media_actor_files
    logger.info("already known actors: %s", actor_files)
    results: list[MediaActorResponse] = []
    for actor_file in actor_files:
        response = actor_to_response(actor_file.media_actor)
        results.append(response)
    return results
@router.put("/files/{file_id}/actors", response_model=List[MediaActorFileResponse])
 def update_file_actors(
    file_id: str, db: SessionDep, actors: List[MediaActorResponse]
 ) -> List[MediaActorFileResponse]:
    mediafile = db.get(MediaFile, file_id)
    if not mediafile:
        raise HTTPException(status_code=404, detail="MediaFile could not be found")
    actor_files = mediafile.media_actor_files
    logger.info("already known actors: %s", actor_files)
    for actor in actors:
        already_associated = False
        for actor_file in actor_files:
            if actor.id == actor_file.media_actor_id:
                logger.info("alreay associated - do nothing")
                already_associated = True
                break
        if not already_associated:
            create_new_mediaactorfile(db, actor.id, mediafile.id)
    db.refresh(mediafile)
    actor_files = mediafile.media_actor_files
    results: List[MediaActorFileResponse] = []
    for actor_file in actor_files:
        response = actorfile_to_response(actor_file)
        results.append(response)
    return results
@router.put("/files/{file_id}", response_model=MediaFileResponse)
 def update_file(
    file_id: str, db: SessionDep, info: MediaFileResponse
 ) -> MediaFileResponse:
    """
    Update MediaFile with given id and data.
    """
    media_file = db.get(MediaFile, file_id)
    if not media_file:
        raise HTTPException(status_code=404, detail="MediaFile could not be found")
    file_to_model(info, media_file)
    db.add(media_file)
    db.commit()
    mediafile = db.get(MediaFile, file_id)
    if not mediafile:
        raise HTTPException(status_code=404, detail="MediaFile could not be updated")
    response = file_to_response(mediafile)
    return response
@router.post("/files", status_code=status.HTTP_201_CREATED)
 def add_file(new_file: MediaFileModel, db: SessionDep) -> MediaFileResponse:
    logger.info("add mediafile %s", new_file)
    try:
        mediaFile: MediaFile = import_mediafile(db, new_file)
    except:
        raise HTTPException(status_code=409, detail="MediaFile duplicate")
    response = file_to_response(mediaFile)
    return response
@@ -0,0 +1,91 @@
 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
@@ -0,0 +1,43 @@
 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.session import SessionDep
 from kontor_model.schema.media.actorfile import MediaActorFileModel, MediaActorFileResponse, actorfile_to_response
 router = APIRouter()
@router.get("/actorfiles", response_model=List[MediaActorFileResponse])
 def get_all_actorfiles(db: SessionDep) -> List[MediaActorFileResponse]:
    results: List[MediaActorFileResponse] = []
    actorfiles = db.query(MediaActorFile).all()
    for media_actorfile in actorfiles:
        response = actorfile_to_response(media_actorfile)
        results.append(response)
    return results
@router.get("/actorfiles/{actorfile_id}", response_model=MediaActorFileResponse)
 def get_actorfile(actorfile_id: str, db: SessionDep) -> MediaActorFileResponse:
    media_actorfile = db.get(MediaActorFile, actorfile_id)
    if not media_actorfile:
        raise HTTPException(status_code=404, detail="MediaActor could not be found")
    response = actorfile_to_response(media_actorfile)
    return response
@router.delete("/actorfiles/{actorfile_id}", status_code=status.HTTP_204_NO_CONTENT)
 def delete_actorfile(actorfile_id: str, db: SessionDep):
    media_actorfile = db.get(MediaActorFile, actorfile_id)
    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
@@ -0,0 +1,25 @@
 from typing import List
 from fastapi import APIRouter
 from kontor_model.db.models.media import MediaArticle
 from src.db.session import SessionDep
 from kontor_model.schema.media.article import MediaArticleResponse, to_response
 router = APIRouter()
@router.get("/articles", response_model=List[MediaArticleResponse])
 def get_all_files(
    db: SessionDep, review: bool = False, download: bool = False
 ) -> List[MediaArticleResponse]:
    """
    Get all MediaVideos.
    """
    results: List[MediaArticleResponse] = []
    articles: List[MediaArticle]
    articles = db.query(MediaArticle).all()
    for article in articles:
        response = to_response(article)
        results.append(response)
    return results
@@ -0,0 +1,42 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.media import MediaVideo
 from src.db.session import SessionDep
 from kontor_model.schema.media.video import MediaVideoResponse, video_to_response
 router = APIRouter()
@router.get("/videos", response_model=List[MediaVideoResponse])
 def get_all_videos(
    db: SessionDep, review: bool = False, download: bool = False
 ) -> List[MediaVideoResponse]:
    """
    Get all MediaVideos.
    """
    results: List[MediaVideoResponse] = []
    files: List[MediaVideo]
    if review:
        files = db.query(MediaVideo).filter(MediaVideo.review.is_(True)).all()
    elif download:
        files = db.query(MediaVideo).filter(MediaVideo.should_download.is_(True)).all()
    else:
        files = db.query(MediaVideo).all()
    for mediafile in files:
        response = video_to_response(mediafile)
        results.append(response)
    return results
@router.get("/videos/{video_id}", response_model=MediaVideoResponse)
 def get_video(video_id: str, db: SessionDep) -> MediaVideoResponse:
    """
    Get MediaVideo by id.
    """
    video = db.get(MediaVideo, video_id)
    if video is None:
        raise HTTPException(status_code=404, detail="MediaVideo could not be found")
    response = video_to_response(video)
    return response
@@ -1,45 +0,0 @@
 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, get_actor_details
 from src.db.session import SessionDep
 from src.schema.media.actor import MediaActorModel, MediaActorResponse
 from src.db.models.media import MediaActor
 router = APIRouter()
@router.get("/actors", response_model=list[MediaActorResponse])
 # def get_all_files(db: SessionDep, review: bool = False, download: bool = False, current_user: Profile = Depends(get_current_user_from_token)) -> List[MediaFileResponse]:
 def get_all_actors(db: SessionDep, review: bool = False, download: bool = False) -> list[MediaActorResponse]: # type: ignore
    results: list[MediaActorResponse] = []
    actors = db.scalars(select(MediaActor)).all()
    for mediaactor in actors:
        response = MediaActorResponse(id=mediaactor.id, name=str(mediaactor.name), url=str(mediaactor.url))
        results.append(response)
    return results
@router.get("/actors/{actor_id}", response_model=MediaActorResponse)
 def get_actor(actor_id: str, db: SessionDep) -> MediaActorResponse: # type: ignore
    media_actor = db.get(MediaActor, actor_id)
    if not media_actor:
        raise HTTPException(status_code=404, detail="MediaActor could not be found")
    response = get_actor_details(media_actor)
    return response
@router.delete("/actors/{actor_id}", status_code=status.HTTP_204_NO_CONTENT)
 def delete_actor(actor_id: str, db: SessionDep): # type: ignore
    media_actor = db.get(MediaActor, actor_id)
    if not media_actor:
        raise HTTPException(status_code=404, detail="MediaActor could not be found")
    logger.info(f"delete MediaActor: {actor_id}")
    delete_mediaactor(db, media_actor.id)
@router.post("/actors", status_code=status.HTTP_201_CREATED)
 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)
    except:
        raise HTTPException(status_code=409, detail="Link duplicate")
    response = get_actor_details(mediaActor)
    return response
@@ -1,33 +0,0 @@
 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, get_actorfile_details
 from src.db.session import SessionDep
 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] = []
    actorfiles = db.scalars(select(MediaActorFile)).all()
    for media_actorfile in actorfiles:
        response = get_actorfile_details(media_actorfile)
        results.append(response)
    return results
@router.get("/actorfiles/{actorfile_id}", response_model=MediaActorFileResponse)
 def get_actorfile(actorfile_id: str, db: SessionDep) -> MediaActorFileResponse: # type: ignore
    media_actorfile = db.get(MediaActorFile, actorfile_id)
    if not media_actorfile:
        raise HTTPException(status_code=404, detail="MediaActor could not be found")
    response = get_actorfile_details(media_actorfile)
    return response
@router.delete("/actorfiles/{actorfile_id}", status_code=status.HTTP_204_NO_CONTENT)
 def delete_actorfile(actorfile_id: str, db: SessionDep): # type: ignore
    media_actorfile = db.get(MediaActorFile, actorfile_id)
    if not media_actorfile:
        raise HTTPException(status_code=404, detail="MediaActor could not be found")
    delete_mediaactorfile(db, media_actorfile.id)
@@ -1,120 +0,0 @@
 from fastapi import APIRouter, status, HTTPException, Depends
 from sqlalchemy import select, Sequence
 from src.core.log_conf import logger
 from src.db.repository.media import create_new_mediaactorfile, create_new_mediafile, delete_mediafile
 from src.db.session import SessionDep
 from src.schema.media.actor import MediaActorResponse
 from src.schema.media.actorfile import MediaActorFileResponse
 from src.schema.media.file import MediaFileResponse, Link, get_file_details, set_file
 from src.db.models.media import MediaFile
 router = APIRouter()
@router.get("/update-titles")
 def update_titles(db: SessionDep) -> list[MediaFileResponse]: # type: ignore
    results: list[MediaFileResponse] = []
    files = db.query(MediaFile).filter(MediaFile.review == True).all()
    for mediafile in files:
        mediafile.update_title()
        db.add(mediafile)
        response = get_file_details(mediafile)
        results.append(response)
    db.commit()
    return results
@router.get("/files", response_model=list[MediaFileResponse])
 # def get_all_files(db: SessionDep, review: bool = False, download: bool = False, current_user: Profile = Depends(get_current_user_from_token)) -> List[MediaFileResponse]:
 def get_all_files(db: SessionDep, review: bool = False, download: bool = False) -> list[MediaFileResponse]: # type: ignore
    results: list[MediaFileResponse] = []
    files: Sequence[MediaFile]
    if review:
        files = db.query(MediaFile).filter(MediaFile.review == True).all() # type: ignore
    elif download:
        files = db.query(MediaFile).filter(MediaFile.should_download == True).all() # type: ignore
    else:
        files = db.scalars(select(MediaFile)).all() # type: ignore
    for mediafile in files: # type: ignore
        response = get_file_details(mediafile)
        results.append(response)
    return results
@router.get("/files/{file_id}", response_model=MediaFileResponse)
 def get_file(file_id: str, db: SessionDep) -> MediaFileResponse: # type: ignore
    mediafile = db.get(MediaFile, file_id)
    if not mediafile:
        raise HTTPException(status_code=404, detail="MediaFile could not be found")
    response = get_file_details(mediafile)
    return response
@router.delete("/files/{file_id}", status_code=status.HTTP_204_NO_CONTENT)
 def delete_file(file_id: str, db: SessionDep): # type: ignore
    mediafile = db.get(MediaFile, file_id)
    if not mediafile:
        raise HTTPException(status_code=404, detail="MediaFile could not be found")
    logger.info(f"delete MediaFile: {file_id}")
    actor_files = mediafile.media_actor_files
    logger.info(f"MediaActorFiles links {len(actor_files)}")
    if len(actor_files) == 0:
        delete_mediafile(db, mediafile.id)
@router.get("/files/{file_id}/actors", response_model=list[MediaActorResponse])
 def get_file_actors(file_id: str, db: SessionDep) -> list[MediaActorResponse]: # type: ignore
    mediafile = db.get(MediaFile, file_id)
    if not mediafile:
        raise HTTPException(status_code=404, detail="MediaFile could not be found")
    actor_files = mediafile.media_actor_files
    logger.info(f"already known actors: {actor_files}")
    results: list[MediaActorResponse] = []
    for actor_file in actor_files:
        response = MediaActorResponse(id=actor_file.media_actor.id, name=actor_file.media_actor.name, url=actor_file.media_actor.url)
        results.append(response)
    return results
@router.put("/files/{file_id}/actors", response_model=list[MediaActorFileResponse])
 def update_file_actors(file_id: str, db: SessionDep, actors: list[MediaActorResponse]) -> list[MediaActorFileResponse]: # type: ignore
    mediafile = db.get(MediaFile, file_id)
    if not mediafile:
        raise HTTPException(status_code=404, detail="MediaFile could not be found")
    actor_files = mediafile.media_actor_files
    logger.info(f"already known actors: {actor_files}")
    for actor in actors:
        already_associated = False
        for actor_file in actor_files:
            if actor.id == actor_file.media_actor_id:
                logger.info("alreay associated - do nothing")
                already_associated = True
                break
        if not already_associated:
            create_new_mediaactorfile(db, actor.id, mediafile.id)
    db.refresh(mediafile)
    actor_files = mediafile.media_actor_files
    results: list[MediaActorFileResponse] = []
    for actor_file in actor_files:
        response = MediaActorFileResponse(id=actor_file.id, actor_id=actor_file.media_actor_id, file_id=actor_file.media_file_id)
        results.append(response)
    return results
@router.put("/files/{file_id}", response_model=MediaFileResponse)
 def update_file(file_id: str, db: SessionDep, info: MediaFileResponse) -> MediaFileResponse: # type: ignore
    mediaFile = db.get(MediaFile, file_id)
    if not mediaFile:
        raise HTTPException(status_code=404, detail="MediaFile could not be found")
    set_file(info, mediaFile)
    db.add(mediaFile)
    db.commit()
    mediafile = db.get(MediaFile, file_id)
    if not mediafile:
        raise HTTPException(status_code=404, detail="MediaFile could not be updated")
    response = get_file_details(mediafile)
    return response
@router.post("/files", status_code=status.HTTP_201_CREATED)
 def add_file(new_link: Link, db: SessionDep) -> MediaFileResponse: # type: ignore
    logger.info(f"add url {new_link.url}")
    try:
        mediaFile: MediaFile = create_new_mediafile(new_link.url, db)
    except:
        raise HTTPException(status_code=409, detail="Link duplicate")
    response = get_file_details(mediaFile)
    return response
@@ -1,16 +0,0 @@
 from typing import List
 from fastapi import APIRouter
 from src.db.session import SessionDep
 from src.schema.tysc.sport import SportResponse
 from src.db.models.tysc import Sport
 router = APIRouter()
@router.get("/sports")
 def get_all_sports(db: SessionDep) -> List[SportResponse]:
    results: list[SportResponse] = []
    sports = db.query(Sport).all()
    for sport in sports:
        results.append(SportResponse(id=sport.id, name=sport.name))
    return results
@@ -0,0 +1,27 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.tysc import Card
 from src.db.session import SessionDep
 from kontor_model.schema.tysc.card import CardResponse, to_response
 router = APIRouter()
@router.get("/cards")
 def get_all_cards(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
@router.get("/cards/{card_id}", response_model=CardResponse)
 def get_card(card_id: str, db: SessionDep) -> CardResponse:
    card = db.get(Card, card_id)
    if card is None:
        raise HTTPException(status_code=404, detail="Card could not be found")
    response = to_response(card)
    return response
@@ -0,0 +1,27 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.tysc import CardSet
 from src.db.session import SessionDep
 from kontor_model.schema.tysc.cardset import CardSetResponse, to_response
 router = APIRouter()
@router.get("/cardsets")
 def get_all_cardsets(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
@router.get("/cardsets/{cardset_id}", response_model=CardSetResponse)
 def get_cardset(cardset_id: str, db: SessionDep) -> CardSetResponse:
    cardset = db.get(CardSet, cardset_id)
    if cardset is None:
        raise HTTPException(status_code=404, detail="Cardset could not be found")
    response = to_response(cardset)
    return response
@@ -0,0 +1,27 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.tysc import FieldPosition
 from src.db.session import SessionDep
 from kontor_model.schema.tysc.fieldposition import FieldPositionResponse, to_response
 router = APIRouter()
@router.get("/positions")
 def get_all_positions(db: SessionDep) -> List[FieldPositionResponse]:
    results: list[FieldPositionResponse] = []
    positions = db.query(FieldPosition).all()
    for position in positions:
        response = to_response(position)
        results.append(response)
    return results
@router.get("/positions/{position_id}", response_model=FieldPositionResponse)
 def get_position(position_id: str, db: SessionDep) -> FieldPositionResponse:
    position = db.get(FieldPosition, position_id)
    if position is None:
        raise HTTPException(status_code=404, detail="Fieldposition could not be found")
    response = to_response(position)
    return response
@@ -0,0 +1,27 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.tysc import Player
 from src.db.session import SessionDep
 from kontor_model.schema.tysc.player import PlayerResponse, to_response
 router = APIRouter()
@router.get("/players")
 def get_all_players(db: SessionDep) -> List[PlayerResponse]:
    results: List[PlayerResponse] = []
    players = db.query(Player).all()
    for player in players:
        response = to_response(player)
        results.append(response)
    return results
@router.get("/players/{player_id}", response_model=PlayerResponse)
 def get_player(player_id: str, db: SessionDep) -> PlayerResponse:
    player = db.get(Player, player_id)
    if player is None:
        raise HTTPException(status_code=404, detail="Player could not be found")
    response = to_response(player)
    return response
@@ -0,0 +1,27 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.tysc import Rooster
 from src.db.session import SessionDep
 from kontor_model.schema.tysc.rooster import RoosterResponse, to_response
 router = APIRouter()
@router.get("/roosters")
 def get_all_roosters(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
@router.get("/roosters/{rooster_id}", response_model=RoosterResponse)
 def get_rooster(rooster_id: str, db: SessionDep) -> RoosterResponse:
    rooster = db.get(Rooster, rooster_id)
    if rooster is None:
        raise HTTPException(status_code=404, detail="Rooster could not be found")
    response = to_response(rooster)
    return response
@@ -0,0 +1,28 @@
 from typing import List
 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
 router = APIRouter()
@router.get("/sports")
 def get_all_sports(db: SessionDep) -> List[SportResponse]:
    results: list[SportResponse] = []
    sports = db.query(Sport).all()
    for sport in sports:
        response = to_response(sport)
        results.append(response)
    return results
@router.get("/sports/{sport_id}", response_model=SportResponse)
 def get_sport(sport_id: str, db: SessionDep) -> SportResponse:
    sport = db.get(Sport, sport_id)
    if sport is None:
        raise HTTPException(status_code=404, detail="Sport could not be found")
    logger.debug(f"create SportResponse for {sport}")
    response: SportResponse = to_response(sport)
    return response
@@ -0,0 +1,27 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.tysc import Team
 from src.db.session import SessionDep
 from kontor_model.schema.tysc.team import TeamResponse, to_response
 router = APIRouter()
@router.get("/teams")
 def get_all_teams(db: SessionDep) -> List[TeamResponse]:
    results: list[TeamResponse] = []
    teams = db.query(Team).all()
    for team in teams:
        response = to_response(team)
        results.append(response)
    return results
@router.get("/teams/{team_id}", response_model=TeamResponse)
 def get_team(team_id: str, db: SessionDep) -> TeamResponse:
    team = db.get(Team, team_id)
    if team is None:
        raise HTTPException(status_code=404, detail="Team could not be found")
    response = to_response(team)
    return response
@@ -0,0 +1,33 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.tysc import Vendor
 from src.db.session import SessionDep
 from kontor_model.schema.tysc.vendor import VendorResponse, to_response
 router = APIRouter()
@router.get("/vendors")
 def get_all_vendors(db: SessionDep) -> List[VendorResponse]:
    """
    retrieve all vendors as json response.
    """
    results: list[VendorResponse] = []
    vendors = db.query(Vendor).all()
    for vendor in vendors:
        response = to_response(vendor)
        results.append(response)
    return results
@router.get("/vendors/{vendor_id}", response_model=VendorResponse)
 def get_vendor(vendor_id: str, db: SessionDep) -> VendorResponse:
    """
    retrieve vendor by id as json response.
    """
    vendor = db.get(Vendor, vendor_id)
    if vendor is None:
        raise HTTPException(status_code=404, detail="Vendor could not be found")
    response = to_response(vendor)
    return response
@@ -1,47 +0,0 @@
 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
@@ -0,0 +1,26 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.admin import Assignment
 from src.db.session import SessionDep
 from kontor_model.schema.user.assignment import AssignmentResponse, to_response
 router = APIRouter()
@router.get("/assignments", response_model=List[AssignmentResponse])
 def get_all_assignments(db: SessionDep) -> List[AssignmentResponse]:
    results: List[AssignmentResponse] = []
    assignments = db.query(Assignment).all()
    for assignment in assignments:
        response = to_response(assignment)
        results.append(response)
    return results
@router.get("/assignments/{assignment_id}", response_model=AssignmentResponse)
 def get_assignment(assignment_id: str, db: SessionDep) -> AssignmentResponse:
    assignment = db.get(Assignment, assignment_id)
    if assignment is None:
        raise HTTPException(status_code=404, detail="Assignment could not be found")
    response = to_response(assignment)
    return response
@@ -0,0 +1,26 @@
 from typing import List
 from fastapi import APIRouter, HTTPException
 from kontor_model.db.models.admin import Permission
 from src.db.session import SessionDep
 from kontor_model.schema.user.permission import PermissionResponse, to_response
 router = APIRouter()
@router.get("/permissions", response_model=List[PermissionResponse])
 def get_all_permissions(db: SessionDep) -> List[PermissionResponse]:
    results: List[PermissionResponse] = []
    permissions = db.query(Permission).all()
    for permission in permissions:
        response = to_response(permission)
        results.append(response)
    return results
@router.get("/permissions/{permission_id}", response_model=PermissionResponse)
 def get_permission(permission_id: str, db: SessionDep) -> PermissionResponse:
    permission = db.get(Permission, permission_id)
    if permission is None:
        raise HTTPException(status_code=404, detail="Permission could not be found")
    response = to_response(permission)
    return response
@@ -0,0 +1,53 @@
 from typing import List
 from fastapi import APIRouter, HTTPException, status
 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.repository.user import create_new_profile
 from src.db.session import SessionDep
 from kontor_model.schema.user.profile import ProfileResponse, ProfileModel, to_response
 router = APIRouter()
@router.get("/profile", response_model=ProfileModel)
 async def read_profile(current_user: CurrentUser):
    return current_user
@router.get("/profiles", response_model=List[ProfileResponse])
 def get_all_profiles(db: SessionDep) -> List[ProfileResponse]:
    results: List[ProfileResponse] = []
    profiles = db.scalars(select(Profile)).all()
    for profile in profiles:
        response = to_response(profile)
        results.append(response)
    return results
@router.get("/profiles/{profile_id}", response_model=ProfileResponse)
 def get_profile(profile_id: str, db: SessionDep) -> ProfileResponse:
    profile = db.get(Profile, profile_id)
    if not profile:
        raise HTTPException(status_code=404, detail="Profile could not be found")
    response = to_response(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:
    logger.info(f"add profile {new_profile.username}")
    try:
        profile: Profile = create_new_profile(new_profile, db)
    except:
        raise HTTPException(status_code=409, detail="Profile duplicate")
    response = to_response(profile)
    return response
@@ -0,0 +1,19 @@
 from typing import List
 from fastapi import APIRouter
 from kontor_model.db.models.admin import Token
 from src.db.session import SessionDep
 from kontor_model.schema.user.token import TokenResponse, to_response
 router = APIRouter()
@router.get("/tokens", response_model=List[TokenResponse])
 def get_all_profiles(db: SessionDep) -> List[TokenResponse]:
    results: List[TokenResponse] = []
    tokens = db.query(Token).all()
    for token in tokens:
        response = to_response(token)
        results.append(response)
    return results
@@ -9,17 +9,21 @@ load_dotenv(dotenv_path=env_path)
 class Settings:
    PROJECT_NAME: str = "Kontor"
-    PROJECT_VERSION: str = "0.3.0"
+    PROJECT_VERSION: str = "0.4.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}"
+    DATABASE_URL: str = (
-    SECRET_KEY: str = os.getenv("SECRET_KEY", "J6GOtcwC2NJI1l0VkHu20PacPFGTxpirBxWwynoHjsc=")
+        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
+    ACCESS_TOKEN_EXPIRE_MINUTES = 60 * 24 * 7  # one week in mins
 settings = Settings()
@@ -0,0 +1,35 @@
 import json
 import time
 from fastapi import Request, Response
 from starlette.middleware.base import BaseHTTPMiddleware
 from src.core.log_conf import logger
 class RequestLoggingMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next) -> Response:
        start_time = time.time()
        path = request.url.path
        if path != "/health":
            # Log request info
            request_info ={
                "method": request.method,
                "path": path,
                "client_ip": request.client.host if request.client else "unknown"
            }
            logger.info("Incoming: %s", json.dumps(request_info))
        # Process request
        response = await call_next(request)
        if path != "/health":
            # Log response info
            duration_ms = (time.time()- start_time)*1000
            response_info = {
                "status_code": response.status_code,
                "duration_ms": round(duration_ms, 2)
            }
            logger.info("completed: %s", json.dumps(response_info))
        return response
@@ -1,60 +1,74 @@
 import logging
 from datetime import datetime, timedelta, timezone
-from typing import Annotated, Dict, List, Optional
+from typing import Annotated, List, Optional
 import bcrypt
-from fastapi import Depends, HTTPException, Request, Security, status
+from fastapi import Depends, HTTPException, Security, status
-from fastapi.openapi.models import OAuthFlows as OAuthFlowsModel
+#from fastapi.openapi.models import OAuthFlows as OAuthFlowsModel
-from fastapi.security import OAuth2, OAuth2PasswordBearer, SecurityScopes
+from fastapi.security import (
-from fastapi.security.utils import get_authorization_scheme_param
+    #OAuth2, 
    OAuth2PasswordBearer, 
    SecurityScopes
 )
 #from fastapi.security.utils import get_authorization_scheme_param
 from jose import JWTError, jwt
 from pydantic import ValidationError
 from src.core.config import settings
 from src.core.log_conf import logger
-from src.db.models.admin import Profile
+from kontor_model.db.models.admin import Profile
-from src.db.repository.admin import get_profile, is_database_empty
+from kontor_model.db.repository.admin import (
    get_profile_by_username,
    get_profile_by_email,
    is_database_empty,
 )
 from src.db.session import SessionLocal
-from src.schema.admin import ProfileModel, TokenData
+from kontor_model.schema.admin.token import TokenData
 from kontor_model.schema.user.profile import ProfileModel, to_model
 oauth2_scheme = OAuth2PasswordBearer(
-    tokenUrl="/api/login/token",
+    tokenUrl="/token",
-    scopes={"me": "read", "admin": "read"},
+    scopes={
        "me": "read",
        "admin": "read",
        "ROLE_ADMIN": "admin",
        "ROLE_MEDIA": "media",
        "ROLE_USER": "user",
    },
 )
-class OAuth2PasswordBearerWithCookie(OAuth2):
+# class OAuth2PasswordBearerWithCookie(OAuth2):
-    def __init__(
+#     def __init__(
-        self,
+#         self,
-        tokenUrl: str,
+#         tokenUrl: str,
-        scheme_name: Optional[str] = None,
+#         scheme_name: Optional[str] = None,
-        scopes: Optional[Dict[str, str]] = None,
+#         scopes: Optional[Dict[str, str]] = None,
-        auto_error: bool = True,
+#         auto_error: bool = True,
-    ):
+#     ):
-        if not scopes:
+#         if not scopes:
-            scopes = {}
+#             scopes = {}
-        flows = OAuthFlowsModel(password={"tokenUrl": tokenUrl, "scopes": scopes})  # type: ignore
+#         flows = OAuthFlowsModel(password={"tokenUrl": tokenUrl, "scopes": scopes})  # type: ignore
-        super().__init__(flows=flows, scheme_name=scheme_name, auto_error=auto_error)
+#         super().__init__(flows=flows, scheme_name=scheme_name, auto_error=auto_error)
-    async def __call__(self, request: Request) -> Optional[str]:
+#     async def __call__(self, request: Request) -> Optional[str]:
-        authorization: str = request.cookies.get("access_token") # changed to accept access token from httpOnly Cookie
+#         authorization: str = request.cookies.get("access_token") # changed to accept access token from httpOnly Cookie
-        scheme, param = get_authorization_scheme_param(authorization)
+#         scheme, param = get_authorization_scheme_param(authorization)
-        if not authorization or scheme.lower() != "bearer":
+#         if not authorization or scheme.lower() != "bearer":
-            if self.auto_error:
+#             if self.auto_error:
-                raise HTTPException(
+#                 raise HTTPException(
-                    status_code=status.HTTP_401_UNAUTHORIZED,
+#                     status_code=status.HTTP_401_UNAUTHORIZED,
-                    detail="Not authenticated",
+#                     detail="Not authenticated",
-                    headers={"WWW-Authenticate": "Bearer"},
+#                     headers={"WWW-Authenticate": "Bearer"},
-                )
+#                 )
-            else:
+#             else:
-                return None
+#                 return None
-        return param
+#         return param
-def authenticate_user(username: str, password: str) -> Optional[Profile]:
+def authenticate_user_by_email(email: str, password: str) -> Optional[Profile]:
    with SessionLocal() as db:
-        user = get_profile(username=username, db=db)
+        user = get_profile_by_email(email=email, db=db)
    logger.debug(user)
    if not user:
        if is_database_empty(db):
@@ -65,7 +79,26 @@ def authenticate_user(username: str, password: str) -> Optional[Profile]:
        return None
    else:
        if bcrypt.checkpw(password.encode(), user.password.encode()):
-            print("User successful authenticated")
+            logger.info("User successful authenticated")
        else:
            logger.info("Authentication failed!")
    return user
 def authenticate_user_by_username(username: str, password: str) -> Optional[Profile]:
    with SessionLocal() as db:
        user = get_profile_by_username(username=username, db=db)
    logger.debug(user)
    if not user:
        if is_database_empty(db):
            logger.info("database is empty, use temporary access")
            user = Profile()
            user.email = "init_user@thpeetz.de"
            return user
        return None
    else:
        if bcrypt.checkpw(password.encode(), user.password.encode()):
            logger.info("User successful authenticated")
        else:
            logger.info("Authentication failed!")
    return user
@@ -103,17 +136,19 @@ async def get_current_user(
            token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM]
        )
        username: str = payload.get("sub")  # type: ignore
-        logger.info("username/email extracted is ", username)
+        logger.info("username/email extracted is %s", username)
        if username is None:
            raise credentials_exception
        scope: str = payload.get("scope", "")
        token_scopes: List[str] = scope.split(" ")
        token_data = TokenData(scopes=token_scopes, username=username)
    except (JWTError, ValidationError):
        logger.info("Exception raised", exc_info=True)
        raise credentials_exception
    with SessionLocal() as db:
-        user = get_profile(username=token_data.username, db=db)  # type: ignore
+        user = get_profile_by_username(username=str(token_data.username), db=db)
    if user is None:
        logger.info("user not found")
        raise credentials_exception
    for scope in security_scopes.scopes:
        if scope not in token_scopes:
@@ -128,19 +163,14 @@ async def get_current_user(
 async def get_current_active_user(
    current_user: Annotated[Profile, Security(get_current_user, scopes=["me"])],
 ) -> ProfileModel:
-    if not current_user.enabled:  # type: ignore
+    if not bool(current_user.enabled):
        raise HTTPException(status_code=400, detail="Inactive user")
-    user_model = ProfileModel(
+    user_model = to_model(current_user)
        username=current_user.user_name,
        email=current_user.email,  # type: ignore
        first_name=current_user.first_name,
        last_name=current_user.last_name,  # type: ignore
        active=current_user.enabled,
    )  # type: ignore
    return user_model
 def get_current_user_from_token(token: str = Depends(oauth2_scheme)):
    """ """
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
@@ -149,14 +179,21 @@ def get_current_user_from_token(token: str = Depends(oauth2_scheme)):
        payload = jwt.decode(
            token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM]
        )
-        username: str = payload.get("sub")  # type: ignore
+        username: Optional[str] = payload.get("sub")
-        logger.info("username/email extracted is ", username)
+        logger.info("username/email extracted is %s", username)
        if username is None:
            raise credentials_exception
-    except JWTError:
+    except JWTError as exception:
-        raise credentials_exception
+        raise credentials_exception from exception
    with SessionLocal() as db:
-        user = get_profile(username=username, db=db)
+        user = get_profile_by_email(email=username, db=db)
    if user is None:
-        raise credentials_exception
+        user = get_profile_by_username(username=username, db=db)
        if user is None:
            raise credentials_exception
    return user
 UserDep = Annotated[Profile, Depends(get_current_user_from_token)]
 CurrentUser =  Annotated[Profile, Depends(get_current_active_user)]
@@ -1,75 +0,0 @@
 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]
@@ -1,27 +0,0 @@
 from typing import Optional
 import uuid
 from datetime import datetime
 from sqlalchemy import func
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 class Base(DeclarativeBase):
    pass
 class BaseMixin:
    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())
    version: Mapped[int] = mapped_column(default=0)
 class BaseVideoMixin:
    cloud_link: Mapped[Optional[str]]
    file_name: Mapped[Optional[str]]
    path: Mapped[str]
    review: Mapped[bool]
    title: Mapped[str]
    url: Mapped[str]
    should_download: Mapped[bool]
@@ -1,50 +0,0 @@
 from sqlalchemy import Column, ForeignKey, Integer, String
 from sqlalchemy.orm import relationship
 from src.db.models.base import Base, BaseMixin
 class Article(Base, BaseMixin):
    __tablename__ = 'article'
    title = Column(String, unique=True)
    article_authors = relationship("ArticleAuthor")
 class Author(Base, BaseMixin):
    __tablename__ = 'author'
    first_name = Column(String)
    last_name = Column(String)
    article_authors = relationship("ArticleAuthor")
    book_authors = relationship("BookAuthor")
 class BookshelfPublisher(Base, BaseMixin):
    __tablename__ = 'bookshelf_publisher'
    name = Column(String, unique=True)
    books = relationship("Book")
 class Book(Base, BaseMixin):
    __tablename__ = 'book'
    isbn = Column(String, unique=True)
    title = Column(String)
    year = Column(Integer, nullable=False)
    publisher_id = Column(String, ForeignKey('bookshelf_publisher.id'), nullable=False)
    publisher = relationship('BookshelfPublisher', back_populates="books")
    book_authors = relationship("BookAuthor")
 class ArticleAuthor(Base, BaseMixin):
    __tablename__ = 'article_author'
    article_id = Column(String, ForeignKey('article.id'), nullable=False)
    article = relationship('Article', back_populates="article_authors")
    author_id = Column(String, ForeignKey('author.id'), nullable=False)
    author = relationship('Author', back_populates="article_authors")
 class BookAuthor(Base, BaseMixin):
    __tablename__ = 'book_author'
    author_id = Column(String, ForeignKey('author.id'), nullable=False)
    author = relationship('Author', back_populates="book_authors")
    book_id = Column(String, ForeignKey('book.id'), nullable=False)
    book = relationship('Book', back_populates="book_authors")
@@ -1,188 +0,0 @@
 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")
@@ -1,77 +0,0 @@
 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 src.db.models.base import Base, BaseMixin, BaseVideoMixin
 class MediaFile(Base, BaseMixin, BaseVideoMixin):
    __tablename__ = 'media_file'
    media_actor_files: Mapped[List["MediaActorFile"]] = relationship(back_populates="media_file")
    def __repr__(self):
        return f'MediaFile({self.id} {self.title} {self.title})'
    def __str__(self):
        return f'{self.title}({self.id})'
 class MediaActor(Base, BaseMixin):
    __tablename__ = 'media_actor'
    name: Mapped[str]
    url: Mapped[Optional[str]] = mapped_column(unique=True)
    media_actor_files = relationship("MediaActorFile")
    def __repr__(self) -> str:
        return f'MediaActor({self.id} {self.name} {self.url})'
    def __str__(self) -> str:
        return f'{self.url}({self.id})'
 class MediaActorFile(Base, BaseMixin):
    __tablename__ = 'media_actor_file'
    media_actor_id: Mapped[str] = mapped_column(ForeignKey("media_actor.id"), nullable=False)
    media_actor: Mapped[MediaActor] = relationship(back_populates="media_actor_files")
    media_file_id: Mapped[str] = mapped_column(ForeignKey("media_file.id"), nullable=True)
    media_file: Mapped[MediaFile] = relationship(back_populates="media_actor_files")
    def __repr__(self):
        return f'MediaActorFile({self.id} {self.media_actor_id} {self.media_file_id})'
    def __str__(self) -> str:
        return f'{self.id} {self.media_actor_id} {self.media_file_id}'
 class MediaArticle(Base, BaseMixin):
    __tablename__ = 'media_article'
    review: Mapped[bool]
    title: Mapped[str]
    url: Mapped[str] = mapped_column(unique=True)
 class MediaVideo(Base, BaseMixin):
    __tablename__ = 'media_video'
    cloud_link: Mapped[str]
    file_name: Mapped[str]
    path: Mapped[str]
    review: Mapped[bool]
    title: Mapped[str]
    url: Mapped[str] = mapped_column(unique=True)
    should_download: Mapped[bool]
    def __repr__(self):
        return f'MediaFile({self.id} {self.title} {self.url})'
    def __str__(self):
        if self.title is None:
            return f'{self.url}({self.id})'
        else:
            return f'{self.title}({self.id})'
@@ -1,100 +0,0 @@
 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")
@@ -1,14 +0,0 @@
 from typing import AnyStr, Optional
 from sqlalchemy.orm import Session
 from src.db.models.admin import Profile
 def get_profile(username: AnyStr, db: Session) -> Optional[Profile]:
    profile = db.query(Profile).filter(Profile.email == username).first()
    return profile
 def is_database_empty(db: Session) -> bool:
    profiles = db.query(Profile).all()
    return len(profiles) == 0
@@ -1,47 +0,0 @@
 import uuid
 from typing import List, Optional
 from sqlalchemy.orm import Session
 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:
    comic_works: List[ArtistWorktypeComicResponse] = []
    comic_works_map = {}
    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, title=work.comic.title, completed=work.comic.completed)
            comic_works_map[worktype_id].comics.append(comic)
        else:
            comic_works_map[worktype_id] = ArtistWorktypeComicResponse(
                worktype=WorktypeResponse(id=worktype_id, name=work.work_type.name),
                comics=[ComicResponse(id=work.comic.id, title=work.comic.title, completed=work.comic.completed)]
            )
    for value in comic_works_map.values():
        comic_works.append(value)
    issue_works: List[ArtistWorktypeIssueResponse] = []
    response = ArtistDetailResponse(
        id=artist.id,
        name=str(artist.name),
        weblink=str(artist.weblink),
        comic_works=comic_works,
        issue_works=issue_works,
    )
    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
        db.add(artist)
        db.commit()
        db.refresh(artist)
    return artist
@@ -1,87 +0,0 @@
 from typing import Dict, List, Optional
 from sqlalchemy.orm import Session
 from src.core.log_conf import logger
 from src.db.models.comic import Comic, Issue
 from src.schema.comics.artist import ArtistResponse
 from src.schema.comics.comic import ComicResponse, ComicSchema
 from src.schema.comics.comic_details import ComicDetailsResponse, ComicWorktypeArtistResponse
 from src.schema.comics.issue import IssueResponse
 from src.schema.comics.issue_details import IssueDetailsResponse
 from src.schema.comics.publisher import PublisherResponse
 from src.schema.comics.volume import VolumeResponse
 from src.schema.comics.worktype import WorktypeResponse
 def list_comics(db: Session) -> List[Comic]:
    comics = db.query(Comic).all()
    return comics
 def get_issue_details(issue: Issue) -> IssueDetailsResponse:
    response = IssueDetailsResponse(
        id=issue.id,
        issue_number=str(issue.issue_number),
        in_stock=bool(issue.in_stock),
        is_read=bool(issue.is_read),
        comic=ComicResponse(id=issue.comic.id, title=issue.comic.title, completed=issue.comic.completed),
        volume=VolumeResponse(id=issue.volume.id, name=issue.volume.name)
    )
    return response
 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
 def get_short_info(comic: Comic) -> ComicResponse:
    response = ComicResponse(
        id=comic.id,
        title=str(comic.title),
        completed=bool(comic.completed == 1)
    )
    return response
 def get_comic_details(comic: Comic) -> ComicDetailsResponse:
    volumes: List[VolumeResponse] = []
    for volume in comic.volumes:
        volumes.append(VolumeResponse(id=volume.id, name=volume.name))
    issues: List[IssueResponse] = []
    for issue in comic.issues:
        issues.append(IssueResponse(
            id=issue.id,
            issue_number=issue.issue_number,
            in_stock=issue.in_stock,
            is_read=issue.is_read
        ))
    works: List[ComicWorktypeArtistResponse] = []
    works_map: Dict[str, ComicWorktypeArtistResponse] = {}
    for work in comic.comic_works:
        worktype_id = work.work_type.id
        if worktype_id in works_map:
            artist = ArtistResponse(id=work.artist.id, name=work.artist.name)
            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(
                worktype=WorktypeResponse(id=worktype_id, name=work.work_type.name), 
                artists=[ArtistResponse(id=work.artist.id, name=work.artist.name)]
            )
    for value in works_map.values():
        works.append(value)
    response = ComicDetailsResponse(
        id=str(comic.id),
        created=str(comic.created_date),
        title=str(comic.title),
        completed=bool(comic.completed),
        current_order=bool(comic.current_order),
        weblink=str(comic.weblink),
        publisher=PublisherResponse(id=comic.publisher.id, name=comic.publisher.name),
        issues=issues,
        volumes=volumes,
        works=works
    )
    return response
@@ -1,24 +0,0 @@
 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
@@ -1,33 +0,0 @@
 import uuid
 from datetime import datetime
 from typing import AnyStr, Optional
 from sqlalchemy.orm import Session
 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:
    worktype = WorkType()
    worktype.id = str(uuid.uuid4())
    worktype.created_date = datetime.now()
    worktype.last_modified_date = datetime.now()
    worktype.name = work.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
        db.add(worktype)
        db.commit()
        db.refresh(worktype)
    return worktype
@@ -1,105 +0,0 @@
 from sqlalchemy.orm import Session
 import uuid
 from datetime import datetime
 from src.core.log_conf import logger
 from src.db.models.media import MediaActor, MediaActorFile, MediaFile, MediaVideo
 from src.schema.media.actor import MediaActorModel, MediaActorResponse
 from src.schema.media.actorfile import MediaActorFileResponse
 from src.webapps.media.forms import AddLinkForm
 def create_new_video(video: AddLinkForm, db: Session) -> MediaVideo:
    print(video.url)
    media_video = MediaVideo()
    media_video.id = str(uuid.uuid4())
    media_video.url = video.url
    media_video.created_date = datetime.now()
    media_video.last_modified_date = datetime.now()
    media_video.review = True
    media_video.should_download = True
    db.add(media_video)
    db.commit()
    db.refresh(media_video)
    print(media_video)
    return media_video
 def create_new_mediafile(link: str, db: Session) -> MediaFile:
    logger.info("create MediaFile with url {link}")
    media_file: MediaFile = MediaFile()
    media_file.id = str(uuid.uuid4())
    media_file.url = link
    media_file.created_date = datetime.now()
    media_file.last_modified_date = datetime.now()
    media_file.version = 0
    media_file.review = True
    media_file.should_download = True
    db.add(media_file)
    db.commit()
    db.refresh(media_file)
    logger.info(f"created {media_file}")
    return media_file
 def delete_mediafile(db: Session, media_file_id: str):
    logger.info(f"delete MediaFile with id {media_file_id}")
    media_file = db.get(MediaFile, media_file_id)
    db.delete(media_file)
    db.commit()
 def create_new_mediaactor(new_actor: MediaActorModel, db: Session) -> MediaActor:
    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:
        media_actor.name = new_actor.name
    media_actor.url = new_actor.url
    media_actor.created_date = datetime.now()
    media_actor.last_modified_date = datetime.now()
    media_actor.version = 0
    db.add(media_actor)
    db.commit()
    db.refresh(media_actor)
    logger.info(f"created {media_actor}")
    return media_actor
 def delete_mediaactor(db: Session, actor_id: str):
    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
        for actor_file in actor_files:
            delete_mediaactorfile(db, actorfile_id=actor_file.id)
    db.refresh(media_actor)
    db.delete(media_actor)
    db.commit()
 def get_actor_details(media_actor: MediaActor) -> MediaActorResponse:
    reponse: MediaActorResponse = MediaActorResponse(id=media_actor.id, name=str(media_actor.name), url=str(media_actor.url))
    return reponse
 def create_new_mediaactorfile(db: Session, actor_id: str, file_id: str) -> MediaActorFile:
    logger.info(f"create MediaActorFile with actor {actor_id} and file {file_id}")
    media_actor_file: MediaActorFile = MediaActorFile()
    media_actor_file.id = str(uuid.uuid4())
    media_actor_file.created_date = datetime.now()
    media_actor_file.last_modified_date = datetime.now()
    media_actor_file.version = 0
    media_actor_file.media_actor_id = actor_id
    media_actor_file.media_file_id = file_id
    db.add(media_actor_file)
    db.commit()
    db.refresh(media_actor_file)
    return media_actor_file
 def delete_mediaactorfile(db: Session, actorfile_id: str):
    logger.info(f"delete MediaActorFile with id {actorfile_id}")
    media_actorfile = db.get(MediaActorFile, actorfile_id)
    db.delete(media_actorfile)
    db.commit()
 def get_actorfile_details(media_actorfile: MediaActorFile) -> MediaActorFileResponse:
    response: MediaActorFileResponse = MediaActorFileResponse(
        id=media_actorfile.id,
        file_id=str(media_actorfile.media_file_id),
        actor_id=str(media_actorfile.media_actor_id)
    )
    return response
@@ -2,18 +2,17 @@ from datetime import datetime
 from typing import Optional
 import uuid
 from src.core.log_conf import logger
-from src.db.models.admin import Assignment, Profile
+from kontor_model.db.models.admin import Assignment, Profile
 from sqlalchemy.orm import Session
-from src.schema.user.profile import ProfileModel, ProfileResponse
+from kontor_model.schema.user.profile import ProfileModel
 def create_new_profile(new_profile: ProfileModel, db: Session) -> Profile:
-    logger.info(f"create MediaActor with url {new_profile.user_name}")
+    logger.info(f"create MediaActor with url {new_profile.username}")
    profile: Profile = Profile()
    profile.id = str(uuid.uuid4())
-    profile.user_name = new_profile.user_name
+    profile.user_name = new_profile.username
    profile.first_name = new_profile.first_name
    profile.last_name = new_profile.last_name
    profile.created_date = datetime.now()
@@ -35,13 +34,6 @@ def delete_profile(db: Session, profile_id: str):
        db.delete(profile)
        db.commit()
 def get_profile_details(profile: Profile) -> ProfileResponse:
    reponse: ProfileResponse = ProfileResponse(
        id=profile.id, 
        user_name=str(profile.user_name)
    )
    return reponse
 def delete_assignment(db: Session, assignment_id: str) -> None:
    logger.info(f"delete Assignment with id {assignment_id}")
    assignment: Optional[Assignment] = db.get(Assignment, assignment_id)
@@ -12,8 +12,10 @@ engine = create_engine(SQLALCHEMY_DATABASE_URL)
 SessionLocal = sessionmaker(bind=engine)
-def get_db() -> Generator:
+def get_db() -> Generator[Session, None, None]:
    """ """
    with SessionLocal() as db:
        yield db
-SessionDep: type[Session] = Annotated[Session, Depends(get_db)]
+
 SessionDep = Annotated[Session, Depends(get_db)]
@@ -6,10 +6,11 @@ from fastapi.staticfiles import StaticFiles
 from src.apis.base import api_router
 from src.apis.version1.healthcheck import health_router
-from src.apis.version1.login import login_router
+from src.apis.version1.admin.login import login_router
 from src.core.config import settings
 from src.core.log_conf import logger
-from src.db.models.base import Base
+from src.core.middleware import RequestLoggingMiddleware
 from kontor_model.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
@@ -23,10 +24,10 @@ async def lifespan(app: FastAPI):
 def include_router(app: FastAPI):
-    app.include_router(api_router)
+    app.include_router(api_router, tags=["api"])
-    app.include_router(web_app_router)
+    app.include_router(web_app_router, tags=["webapp"])
-    app.include_router(health_router)
+    app.include_router(health_router, tags=["admin"])
-    app.include_router(login_router)
+    app.include_router(login_router, tags=["webapp"])
 def configure_static(app: FastAPI):
@@ -41,6 +42,7 @@ def add_middle_ware(app: FastAPI):
        allow_methods=["*"],
        allow_headers=["*"],
    )
    app.add_middleware(RequestLoggingMiddleware)
 def create_tables():
@@ -1,27 +0,0 @@
 from typing import Optional, List
 from pydantic import BaseModel
 class Token(BaseModel):
    access_token: str
    token_type: str
 class TokenData(BaseModel):
    username: Optional[str] = None
    scopes: List[str] = []
 class ProfileModel(BaseModel):
    username: str
    email: str
    first_name: str
    last_name: str
    active: bool
 class HealthCheck(BaseModel):
    """
    Health check model
    """
    status: str = "ok"
@@ -1,14 +0,0 @@
 from pydantic import BaseModel
 class ArtistCreation(BaseModel):
    id: str
    name: str
 class ArtistResponse(BaseModel):
    id: str
    name: str
 class AddArtist(BaseModel):
    id: str
    name: str
@@ -1,22 +0,0 @@
 from typing import List
 from pydantic import BaseModel
 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):
    worktype: WorktypeResponse
    comics: List[ComicResponse]
 class ArtistWorktypeIssueResponse(BaseModel):
    worktype: WorktypeResponse
    issues: List[IssueDetailsResponse]
 class ArtistDetailResponse(BaseModel):
    id: str
    name: str
    weblink: str
    comic_works: List[ArtistWorktypeComicResponse]
    issue_works: List[ArtistWorktypeIssueResponse]
@@ -1,17 +0,0 @@
 from typing import Optional
 from pydantic import BaseModel, AnyUrl
 from src.core.log_conf import logger
 class ComicResponse(BaseModel):
    id: str
    title: str
    completed: bool
 class ComicSchema(BaseModel):
    id: str
    title: str
    weblink: Optional[AnyUrl]
    completed: Optional[bool]
    current_order: Optional[bool]
@@ -1,26 +0,0 @@
 from typing import List
 from pydantic import BaseModel
 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):
    worktype: WorktypeResponse
    artists: List[ArtistResponse]
 class ComicDetailsResponse(BaseModel):
    id: str
    created: str
    title: str
    completed : bool
    current_order : bool
    weblink: str
    publisher: PublisherResponse
    issues: List[IssueResponse]
    volumes: List[VolumeResponse]
    works: List[ComicWorktypeArtistResponse]
@@ -1,8 +0,0 @@
 from pydantic import BaseModel
 class IssueResponse(BaseModel):
    id: str
    issue_number: str
    in_stock: bool
    is_read: bool
@@ -1,13 +0,0 @@
 from pydantic import BaseModel
 from src.schema.comics.comic import ComicResponse
 from src.schema.comics.volume import VolumeResponse
 class IssueDetailsResponse(BaseModel):
    id: str
    issue_number: str
    in_stock: bool
    is_read: bool
    comic: ComicResponse
    volume: VolumeResponse | None
@@ -1,6 +0,0 @@
 from pydantic import BaseModel
 class PublisherResponse(BaseModel):
    id: str
    name: str
@@ -1,14 +0,0 @@
 from typing import List
 from pydantic import BaseModel
 from src.schema.comics.comic import ComicResponse
 from src.schema.comics.publisher import PublisherResponse
 class PublisherDetailsResponse(BaseModel):
    id: str
    name: str
    parent_publisher: PublisherResponse | None
    imprints: List[PublisherResponse]
    comics: List[ComicResponse]
@@ -1,6 +0,0 @@
 from pydantic import BaseModel
 class VolumeResponse(BaseModel):
    id: str
    name: str
@@ -1,9 +0,0 @@
 from pydantic import BaseModel
 class AddWorkType(BaseModel):
    worktype: str
 class WorktypeResponse(BaseModel):
    id: str
    name: str
@@ -1,12 +0,0 @@
 from typing import Optional
 from pydantic import BaseModel
 class MediaActorResponse(BaseModel):
    id: str
    name: Optional[str]
    url: str
 class MediaActorModel(BaseModel):
    name: Optional[str]
    url: str
@@ -1,10 +0,0 @@
 from datetime import datetime
 from src.db.models.media import MediaActorFile
 from pydantic import BaseModel
 class MediaActorFileResponse(BaseModel):
    id: str
    file_id: str
    actor_id: str
@@ -1,40 +0,0 @@
 from datetime import datetime
 from src.db.models.media import MediaFile
 from pydantic import BaseModel
 class MediaFileResponse(BaseModel):
    id: str
    title: str | None = None
    file_name: str | None = None
    cloud_link: str | None = None
    url: str | None = None
    review: bool = False
    should_download: bool = False
 class Link(BaseModel):
    url: str
 def get_file_details(mediafile: MediaFile) -> MediaFileResponse:
    response = MediaFileResponse(id=mediafile.id,
                                 title=mediafile.title,
                                 file_name=mediafile.file_name,
                                 cloud_link=mediafile.cloud_link,
                                 url=str(mediafile.url),
                                 review=mediafile.review,
                                 should_download=mediafile.should_download)
    #print(f"id: {mediafile.id}: review: {response.review} <- {mediafile.review}")
    #print(f"id: {mediafile.id}: download: {response.should_download} <- {mediafile.should_download}")
    return response
 def set_file(model: MediaFileResponse, mediafile: MediaFile) -> None:
    mediafile.file_name = model.file_name
    mediafile.cloud_link = model.cloud_link
    if model.url is not None:
        mediafile.url = model.url
    if model.title is not None:
        mediafile.title = model.title
    mediafile.last_modified_date = datetime.now()
    mediafile.review = model.review
    mediafile.should_download = model.should_download
@@ -1,5 +0,0 @@
 from pydantic import BaseModel
 class AddLink(BaseModel):
    url: str
@@ -1,8 +0,0 @@
 from typing import AnyStr
 from pydantic import BaseModel
 class SportResponse(BaseModel):
    id: AnyStr
    name: str
@@ -1,13 +0,0 @@
 from pydantic import BaseModel
 from src.db.models.admin import Profile
 class ProfileResponse(BaseModel):
    id: str
    user_name: str
 class ProfileModel(BaseModel):
    user_name: str
    first_name: str
    last_name: str
@@ -0,0 +1,29 @@
 {% extends "shared/base.html" %}
 {% block title %}
  <title>Add a Lofi Link</title>
 {% endblock %}
 {% block content %}
  <div class="container">
    <div class="row">
      <div class="text-danger font-weight-bold">
        {% for error in errors %}
          <li>{{error}}</li>
        {% endfor %}
      </div>
    </div>
    <div class="row my-5">
      <h3 class="text-center display-4">Add a Lofi Link</h3>
      <form method="POST">
        <div class="mb-3">
          <input type="text" required class="form-control" name="url" value="{{url}}" placeholder="Lofi Link here">
        </div>
        <button type="submit" class="btn btn-primary">Submit</button>
      </form>
    </div>
  </div>
 {% endblock %}
@@ -0,0 +1,51 @@
 {% extends "shared/base.html" %}
 {% block title %}
  <title>MediaLofi Detail</title>
 {% endblock %}
 {% block content %}
  <div class="container">
  <div class="row">
    <div class="col">
      <h1 class="display-5">MediaLofi Detail</h1>
    </div>
  </div>
  <div class="row">
      <table class="table table-striped table-hover">
        <tbody>
          <tr>
            <th scope="row">MediaLofi Title</th>
            <td colspan="2">{{medialofi.title}}</td>
          </tr>
          <tr>
            <th scope="row">MediaLofi URL</th>
            <td colspan="2">{{medialofi.url}}</td>
          </tr>
          <tr>
            <th scope="row">MediaLofi Download?</th>
            <td colspan="2">{{medialofi.should_download}}</td>
          </tr>
          <tr>
            <th scope="row">MediaLofi Review?</th>
            <td colspan="2">{{medialofi.review}}</td>
          </tr>
          <tr>
            <th scope="row">Data Created</th>
            <td colspan="2">{{medialofi.created_date}}</td>
          </tr>
          <tr>
            <th scope="row">Data Modified</th>
            <td colspan="2">{{medialofi.last_modified_date}}</td>
          </tr>
          <tr>
            <th scope="row">Data Version</th>
            <td colspan="2">{{medialofi.version}}</td>
          </tr>
        </tbody>
    </table>
  </div>
 </div>
 {% endblock %}
@@ -0,0 +1,29 @@
 {% extends "shared/base.html" %}
 {% block title %}
  <title>Lofi Links</title>
 {% endblock %}
 {% block content %}
  {% with msg=msg %}
    {% include "components/alerts.html" %}
  {% endwith %}
  <div class="container">
    <table class="table table-hover">
      <thead><tr>
        <th scope="col">Titel</th>
        <th scope="col">Review</th>
        <th scope="col">Download</th>
      </tr></thead>
      <tbody>
        {% for medialofi in medialofis %}
        <tr>
           <th scope="row"><a href="/media/lofi/{{medialofi.id}}">{{medialofi.title}}</a></th>
           <td>{% with check=medialofi.review %}{% include "components/check.html" %}{% endwith %}</td>
           <td>{% with check=medialofi.should_download %}{% include "components/check.html" %}{% endwith %}</td>
        </tr>
        {% endfor %}
      </tbody>
    </table>
  </div>
 {% endblock %}
@@ -2,4 +2,5 @@
    <a href="/media/files/">MediaFiles</a>
    <a href="/media/actors/">MediaActors</a>
    <a href="/media/videos/">MediaVideos</a>
    <a href="/media/lofi/">MediaLofi</a>
 </div>
@@ -2,7 +2,7 @@ from typing import Optional
 from fastapi import APIRouter, Request
 from fastapi.templating import Jinja2Templates
-from src.db.models.admin import Permission, Profile
+from kontor_model.db.models.admin import Permission, Profile
 from src.db.session import SessionDep
 templates = Jinja2Templates(directory="src/templates")
@@ -1,9 +1,5 @@
-# from src.apis.version1.admin import login_for_access_token
+from src.apis.version1.admin.login import login_for_token_cookie
-from fastapi.security import OAuth2PasswordRequestForm
+from fastapi import APIRouter
 from src.apis.version1.admin import login_for_token_cookie
 from src.db.session import SessionDep
 from fastapi import APIRouter, Depends
 from fastapi import HTTPException
 from fastapi import Request
 from fastapi.templating import Jinja2Templates
@@ -20,7 +16,7 @@ def login(request: Request):
@router.post("/login/")
-async def login(request: Request):
+async def validate_login(request: Request):
    form = LoginForm(request)
    await form.load_data()
    if await form.is_valid():
@@ -31,6 +27,8 @@ async def login(request: Request):
            return response
        except HTTPException:
            form.__dict__.update(msg="")
-            form.__dict__.get("errors").append("Incorrect Email or Password")
+            errors = form.__dict__.get("errors")
            if errors:
                errors.append("Incorrect Email or Password")
            return templates.TemplateResponse("auth/login.html", form.__dict__)
    return templates.TemplateResponse("auth/login.html", form.__dict__)
@@ -4,20 +4,21 @@ from fastapi.templating import Jinja2Templates
 from src.webapps.admin import route_admin
 from src.webapps.auth import route_login
 from src.webapps.comic import route_comics, route_worktype, route_artists
-from src.webapps.media import route_actors, route_media, route_videos
+from src.webapps.media import route_actors, route_lofi, route_media, route_videos
 templates = Jinja2Templates(directory="src/templates")
 api_router = APIRouter()
-api_router.include_router(route_comics.router)
+api_router.include_router(route_comics.router, tags=["webapp"])
-api_router.include_router(route_artists.router)
+api_router.include_router(route_artists.router, tags=["webapp"])
-api_router.include_router(route_worktype.router)
+api_router.include_router(route_worktype.router, tags=["webapp"])
-api_router.include_router(route_media.router)
+api_router.include_router(route_media.router, tags=["webapp"])
-api_router.include_router(route_actors.router)
+api_router.include_router(route_actors.router, tags=["webapp"])
-api_router.include_router(route_videos.router)
+api_router.include_router(route_videos.router, tags=["webapp"])
-api_router.include_router(route_login.router)
+api_router.include_router(route_lofi.router, tags=["webapp"])
-api_router.include_router(route_admin.router)
+api_router.include_router(route_login.router, tags=["webapp"])
 api_router.include_router(route_admin.router, tags=["webapp"])
-@api_router.get("/")
+@api_router.get("/", tags=["webapp"])
 def home(request: Request, msg: str | None = None):
    return templates.TemplateResponse("index.html", {"request": request, "msg": msg})
@@ -2,14 +2,13 @@ from fastapi import APIRouter, Request, status, Form
 from fastapi.templating import Jinja2Templates
 from fastapi.responses import RedirectResponse
-from src.db.models.comic import Artist
+from kontor_model.db.models.comic import Artist
 from typing import AnyStr
-from src.db.repository.comics.artist import update_artist
+from kontor_model.db.repository.comics.artist import update_artist
 from src.db.session import SessionDep
 #from src.db.repository.comic import create_new_worktype, update_worktype
-from src.main import logger
+from kontor_model.schema.comics.artist import AddArtist
 from src.schema.comics.artist import AddArtist
 from src.webapps.comic.forms.artist import AddArtistForm
 #from src.schema.comics.worktype import AddWorkType
@@ -35,7 +34,7 @@ def edit_artist(db: SessionDep, request: Request, artist_id: str):
    return templates.TemplateResponse("comic/artist_edit.html", {"request": request, "artist_name": artist.name, "artist_link": artist.weblink})
@router.post("/artist/edit/{artist_id}")
-async def edit_artist(request: Request, db: SessionDep, artist_id: str, action: str = Form(...), artist_name: str = Form(...), artist_link: str = Form(...)):
+async def edit_artist_post(request: Request, db: SessionDep, artist_id: str, action: str = Form(...), artist_name: str = Form(...), artist_link: str = Form(...)):
    if action == "cancel":
        return RedirectResponse(f"/comic/artists/{artist_id}", status_code=status.HTTP_303_SEE_OTHER)
    form = AddArtistForm(request, artist_id, artist_name, artist_link)
@@ -2,16 +2,16 @@ from fastapi import APIRouter, Form, Request, status
 from fastapi.templating import Jinja2Templates
 from fastapi.responses import RedirectResponse
-from src.db.models.comic import Comic, Publisher, Issue
+from kontor_model.db.models.comic import Comic, Publisher, Issue
 from typing import AnyStr
 from src.core.log_conf import logger
-from src.db.repository.comics.comic import update_comic
+from kontor_model.db.repository.comics.comic import update_comic
 from src.db.session import SessionDep
-from src.schema.comics.comic import ComicSchema
+from kontor_model.schema.comics.comic import ComicSchema
 from src.webapps.comic.forms.comic import ValidateComicForm
 templates = Jinja2Templates(directory="src/templates")
-router = APIRouter(include_in_schema=False, prefix="/comic")
+router = APIRouter(include_in_schema=True, prefix="/comic")
@router.get("/comics")
 def get_comics(db: SessionDep, request: Request, msg: str | None = None):
@@ -58,7 +58,7 @@ async def validate_comic(request: Request, db: SessionDep, comic_id: str, action
    if form.is_valid():
        try:
            comic = ComicSchema(**form.__dict__)
-            comic = update_comic(comic=comic, comic_id=comic_id, db=db)
+            comic = update_comic(new_comic=comic, comic_id=comic_id, db=db)
            return RedirectResponse(f"/comic/comics/{comic.id}", status_code=status.HTTP_303_SEE_OTHER)
        except Exception as e:
            print(e)
@@ -2,13 +2,13 @@ from fastapi import APIRouter, Request, status
 from fastapi.templating import Jinja2Templates
 from fastapi.responses import RedirectResponse
-from src.db.models.comic import WorkType
+from kontor_model.db.models.comic import WorkType
 from typing import AnyStr
-from src.db.repository.comics.worktype import create_new_worktype, update_worktype
+from kontor_model.db.repository.comics.worktype import create_new_worktype, update_worktype
 from src.db.session import SessionDep
 from src.main import logger
-from src.schema.comics.worktype import AddWorkType
+from kontor_model.schema.comics.worktype import AddWorkType
 from src.webapps.comic.forms.worktype import AddWorktypeForm
 templates = Jinja2Templates(directory="src/templates")
@@ -10,7 +10,7 @@ class AddLinkForm:
    async def load_data(self):
        form = await self.request.form()
-        self.url = form.get("url")
+        self.url = str(form.get("url"))
    def is_valid(self):
        if not self.url or not (self.url.__contains__("http")):
@@ -2,7 +2,7 @@ from typing import AnyStr
 from fastapi import APIRouter, Request
 from fastapi.templating import Jinja2Templates
-from src.db.models.media import MediaActor
+from kontor_model.db.models.media import MediaActor
 from src.db.session import SessionDep
 templates = Jinja2Templates(directory="src/templates")
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Thomas Peetz	d80aefe6b2	add publishing of kontor-model Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 5s Details	2026-08-26 18:33:35 +02:00
Thomas Peetz	652378e7de	update kontor-api Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-08-25 17:45:03 +02:00
tpeetz	57b942a9ca	update Vaadin to 25.2.6 (#95 ) Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details Co-authored-by: Thomas Peetz <thomas.peetz@cimt-ag.de> Reviewed-on: #95	2026-08-25 14:15:18 +00:00
Thomas Peetz	bda453a92a	change to version 0.4.0-SNAPSHOT Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-08-25 11:11:51 +02:00
Thomas Peetz	a113f08ddc	create release 0.3.0 Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-08-25 09:43:49 +02:00
tpeetz	cc631a14ed	Merge pull request 'Vorbereitung Release 03.0' (#94 ) from develop/0.3.0 into main Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 5s Details Reviewed-on: #94	2026-08-25 06:01:17 +00:00
Thomas Peetz	9476d8853e	add MediaLofiView Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-08-24 12:55:05 +02:00
tpeetz	8cc58aed5b	implement routes for MediaFile, MediaVideo and MediaLofi Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-08-23 21:31:49 +02:00
tpeetz	ec274a60d9	add build an git info Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-08-23 00:48:18 +02:00
tpeetz	5b7c41c829	add Routes and Processors Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-08-22 02:04:48 +02:00
Thomas Peetz	f73ec33aeb	add CheckLinkProcessor Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 7s Details	2026-08-21 19:46:56 +02:00
Thomas Peetz	cdde57e033	remove deploy.gradle and use deploy--kontor.sh Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-08-19 16:42:16 +02:00
tpeetz	9d07ed9bfb	add script to deploy Kontor from Nexus Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-08-19 14:39:46 +00:00
Thomas Peetz	59e705d012	using Gradle to deploy Kontor Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-08-19 15:57:53 +02:00
Thomas Peetz	3b50a94928	add monitoring of Spring Boot Camel routes Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-08-19 13:51:32 +02:00
Thomas Peetz	fd5bb14e77	add Container build file to package precompiled binary Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-08-18 17:11:10 +02:00
tpeetz	a786607608	fix build problems Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-08-16 23:01:14 +02:00
tpeetz	031d71406c	change queue names Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 5s Details	2026-08-14 22:45:34 +02:00
Thomas Peetz	48149b67cf	extract SQLAlchemy model in separate python library	2026-08-14 16:39:46 +02:00
Thomas Peetz	9f0a0c1d1e	Revert "Update Vaadin and Spring Boot version" Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 6s Details This reverts commit `7555cfd51d`.	2026-08-13 14:05:48 +02:00
Thomas Peetz	7555cfd51d	Update Vaadin and Spring Boot version Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 6s Details	2026-08-13 14:04:30 +02:00
Thomas Peetz	ea038ec70c	refactor package layout Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 7s Details	2026-08-12 19:05:06 +02:00
Thomas Peetz	ecfa0eb6d8	remove subprojects integration and kontor-data Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-08-12 15:19:04 +02:00
Thomas Peetz	fe63a80b23	update vaadin and lombok versionsand disable asciidoctor Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-08-12 13:28:41 +02:00
tpeetz	567e254840	add kontor-data to extract data model Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 10s Details	2026-08-10 22:49:46 +02:00
Thomas Peetz	a4975928ae	add integration subproject for Camel routes Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 52s Details	2026-08-10 15:23:32 +02:00
Thomas Peetz	1dcf342736	add queues and processing Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-08-05 15:46:39 +02:00
tpeetz	6abbe2e585	Add reading queue media.link.add Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-08-04 23:22:26 +02:00
tpeetz	8eecd47399	setup basic project with Python Robyn Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 5s Details	2026-08-02 17:39:41 +02:00
tpeetz	9d01925097	add kontor-robyn Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 5s Details	2026-07-31 22:46:46 +02:00
Thomas Peetz	bd721a8e64	add msgspec to Python projects Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-31 18:28:23 +02:00
Thomas Peetz	c4932a4665	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-31 04:07:07 +02:00
Thomas Peetz	def3f7ea11	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-31 04:06:35 +02:00
Thomas Peetz	bef7b0bd59	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-07-31 04:06:02 +02:00
Thomas Peetz	5655bc5322	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-31 04:05:23 +02:00
Thomas Peetz	375438a8fa	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 2s Details	2026-07-31 04:02:25 +02:00
Thomas Peetz	90b1e8def3	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-31 04:01:54 +02:00
Thomas Peetz	816165579c	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 5s Details	2026-07-31 04:00:04 +02:00
Thomas Peetz	fbcdbb3e1a	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 7s Details	2026-07-31 03:59:26 +02:00
Thomas Peetz	e46ab25920	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 5s Details	2026-07-31 03:57:45 +02:00
Thomas Peetz	1fa64bf5ce	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-07-31 02:40:12 +02:00
Thomas Peetz	fdb9da358a	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-07-31 00:59:26 +02:00
Thomas Peetz	235f64aa08	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-31 00:57:12 +02:00
Thomas Peetz	9f17823922	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-07-30 22:37:35 +02:00
Thomas Peetz	0c6b26b79e	use msgspec to parse message Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-30 22:35:25 +02:00
Thomas Peetz	c7a322f29d	add msgspec to Python projects Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 9s Details	2026-07-30 17:37:17 +02:00
tpeetz	32dcd43fe5	add message sending with stomp protocol Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-26 22:08:49 +02:00
tpeetz	5edb929b0f	fix generating Container image build Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 11s Details	2026-07-26 19:59:56 +02:00
tpeetz	f0cf98d36e	remove asciidoctor from kontor-spring Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-23 05:12:03 +02:00
tpeetz	19e7eba250	add check for short filenames Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-07-22 23:20:51 +02:00
tpeetz	81d6018e0f	add Nexus config Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-22 22:54:36 +02:00
tpeetz	c685e9aca5	fix SNAPSHOT Version Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-07-22 17:09:36 +00:00
tpeetz	d39c14cd9a	change creation of MediaFile Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-07-22 19:00:39 +02:00
tpeetz	2ce6bbc083	fix messageobject Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-07-21 20:51:20 +00:00
tpeetz	3a351ac5b7	fix json conversion Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 8s Details	2026-07-21 18:55:42 +00:00
tpeetz	31c01c3033	adding dry-run option Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 9s Details	2026-07-11 17:38:24 +02:00
tpeetz	0d5ee0dd63	implement REST API for adding MediaFileActors Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 11s Details	2026-06-14 01:58:57 +02:00
tpeetz	b039ae97a9	add subproject kontor-rails Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-06-01 23:47:57 +02:00
tpeetz	71bd7641dc	add checking dirs to cjeck_kontor.py Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-05-31 23:17:32 +02:00
tpeetz	e70b3ab486	fix problem when deleting MediaFile with MediaActor relations Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-05-31 17:47:27 +02:00
tpeetz	6c4ff8bcad	check for duplicate links Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-05-31 00:18:40 +02:00
Thomas Peetz	c885f6cc02	add missing endpoints for creating items Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-05-26 22:43:04 +02:00
tpeetz	0f9c90b883	synchronize data between configured servers Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-05-23 20:32:04 +02:00
Thomas Peetz	8d684908e6	update cli scripts to use REST API Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 2s Details	2026-05-21 16:51:38 +02:00
Thomas Peetz	40b498ed2a	complete loading single items Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-05-21 13:43:53 +02:00
tpeetz	6269b54ee8	check if more than one server is configured before syncing Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 9s Details	2026-05-20 21:43:17 +02:00
Thomas Peetz	bbc00ae2cc	add endpoints to get items by id Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-05-20 18:34:44 +02:00
Thomas Peetz	944420802f	added all missing endpoints Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-05-20 14:08:10 +02:00
tpeetz	d23d1f306a	add missing comics endpoints Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-05-19 23:00:19 +02:00
tpeetz	6077f685e0	Remove obsolete endpoints (#89 ) Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details Remove endpoints api/login/token and api/login/profile --------- Co-authored-by: Thomas Peetz <thomas.peetz@cimt-ag.de> Reviewed-on: #89	2026-05-19 17:52:30 +00:00
tpeetz	f9f4a70a79	add mailaccount endpoint Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 3s Details	2026-05-18 22:01:20 +02:00
Thomas Peetz	71724ac800	add missing endpoints Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 5s Details	2026-05-18 16:45:56 +02:00
tpeetz	6dd8e12218	secure media endpoints Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 2s Details	2026-05-17 21:48:40 +02:00
tpeetz	cd033f458d	add missing endpoints Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 5s Details	2026-05-17 19:52:00 +02:00
tpeetz	1b58ec8e27	remove obsolete scripts	2026-05-17 01:08:50 +02:00
Thomas Peetz	85b5168445	fix typo in workflow demo.yaml Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 4s Details	2026-05-05 18:05:19 +02:00
Thomas Peetz	e8763fe635	test gitea actions Gitea Actions Demo / Explore-Gitea-Actions (push) Successful in 13s Details	2026-05-05 18:02:08 +02:00
Thomas Peetz	69e58e6dfb	Add environment variable for DB server	2026-05-04 15:21:18 +02:00
Thomas Peetz	d8914627a3	move *.service files to subdirectory container and add service file for standalone operations in standalone	2026-05-04 15:02:41 +02:00
Thomas Peetz	b256e20491	renamed systemd unit files	2026-04-27 07:08:41 +02:00
tpeetz	a8df860752	Merge branch 'feature/44-evaluate-typst-for-documentation' into 'develop/0.3.0' Resolve "Evaluate Typst for documentation" Closes #44 See merge request tpeetz/kontor!42	2026-04-26 21:09:54 +02:00
tpeetz	4e88b52dc3	use separate files for chapters	2026-04-26 21:09:06 +02:00
tpeetz	9772c9f554	add subprojekt kontor-doc	2026-04-26 16:08:17 +02:00
tpeetz	e81d473a69	Einrichtung Build	2026-04-23 23:14:26 +02:00
tpeetz	aca9a1aa4a	integrate kontor-angular	2026-04-19 20:05:50 +02:00
tpeetz	57129c2d37	integration von kontor-angular	2026-04-18 00:29:25 +02:00
tpeetz	e09f7cddf3	rename Dockerfile to Containerfile and integrate kontor-angular in pod kontor	2026-04-17 00:18:50 +02:00
Thomas Peetz	a68dd05794	update kontor-api to reflect api changes	2026-04-15 14:38:38 +02:00
Thomas Peetz	62e22c56c4	update usage of api for login by email or username	2026-04-15 11:32:18 +02:00
Thomas Peetz	7aa6a12044	improve konto-vue/Containerfile by explicitly stating images	2026-04-15 10:26:35 +02:00
tpeetz	39a0759b0b	fix OAuth authentication	2026-04-12 20:08:42 +02:00
tpeetz	e82f2825ae	update systemd service files and add script to copy these files	2026-04-12 17:51:19 +02:00
tpeetz	74d29ae8ef	Merge branch 'feature/43-typeerror-not-all-arguments-converted-during-string-formatting' into 'develop/0.3.0' Resolve "TypeError: not all arguments converted during string formatting" Closes #43 See merge request tpeetz/kontor!41	2026-04-12 17:14:46 +02:00
tpeetz	614c5f20aa	Resolve "TypeError: not all arguments converted during string formatting"	2026-04-12 17:14:46 +02:00