move kontor_model in kontor-api (#98)

Co-authored-by: Thomas Peetz <thomas.peetz@cimt-ag.de>
Reviewed-on: #98

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

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+
+class HealthCheck(BaseModel):
+    """
+    Health check model
+    """
+
+    status: str = "ok"

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

@@ -0,0 +1,8 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class LoginRequest(BaseModel):
+    email: Optional[str] = None
+    password: Optional[str] = None

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

@@ -0,0 +1,34 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.admin import MailAccount
+
+
+class MailAccountResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    host: str
+    port: int
+    protocol: str
+    user_name: str
+    password: str
+    start_tls: bool
+
+
+def to_response(account: MailAccount) -> MailAccountResponse:
+    response: MailAccountResponse = MailAccountResponse(
+        id=account.id,
+        created_date=account.created_date,
+        last_modified_date=account.last_modified_date,
+        version=account.version,
+        host=str(account.host),
+        port=account.port,
+        protocol=str(account.protocol),
+        user_name=str(account.user_name),
+        password=str(account.password),
+        start_tls=bool(account.start_tls),
+    )
+    return response

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

@@ -0,0 +1,13 @@
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+
+class TokenData(BaseModel):
+    username: Optional[str] = None
+    scopes: List[str] = []

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

@@ -0,0 +1,23 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.bookshelf import Article
+
+
+class ArticleResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    title: str
+
+def to_response(article:  Article) -> ArticleResponse:
+    response: ArticleResponse = ArticleResponse(
+            id=article.id,
+            created_date=article.created_date,
+            last_modified_date=article.last_modified_date,
+            version=article.version,
+            title=str(article.title)
+    )
+    return response

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

@@ -0,0 +1,25 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.bookshelf import ArticleAuthor
+
+
+class ArticleAuthorResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    article_id: str
+    author_id: str
+
+def to_response(articleauthor:  ArticleAuthor) -> ArticleAuthorResponse:
+    response: ArticleAuthorResponse = ArticleAuthorResponse(
+            id=articleauthor.id,
+            created_date=articleauthor.created_date,
+            last_modified_date=articleauthor.last_modified_date,
+            version=articleauthor.version,
+            article_id=str(articleauthor.article_id),
+            author_id=str(articleauthor.author_id)
+    )
+    return response

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

@@ -0,0 +1,25 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.bookshelf import Author
+
+
+class AuthorResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    first_name: str
+    last_name: str
+
+def to_response(author:  Author) -> AuthorResponse:
+    response: AuthorResponse = AuthorResponse(
+            id=author.id,
+            created_date=author.created_date,
+            last_modified_date=author.last_modified_date,
+            version=author.version,
+            first_name=str(author.first_name),
+            last_name=str(author.last_name)
+    )
+    return response

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

@@ -0,0 +1,29 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.bookshelf import Book
+
+
+class BookResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    isbn: str
+    title: str
+    year: int
+    publisher_id: str
+
+def to_response(book:  Book) -> BookResponse:
+    response: BookResponse = BookResponse(
+            id=book.id,
+            created_date=book.created_date,
+            last_modified_date=book.last_modified_date,
+            version=book.version,
+            isbn=str(book.isbn),
+            title=str(book.title),
+            year=book.year,
+            publisher_id=str(book.publisher_id)
+    )
+    return response

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

@@ -0,0 +1,25 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.bookshelf import BookAuthor
+
+
+class BookAuthorResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    author_id: str
+    book_id: str
+
+def to_response(bookauthor:  BookAuthor) -> BookAuthorResponse:
+    response: BookAuthorResponse = BookAuthorResponse(
+            id=bookauthor.id,
+            created_date=bookauthor.created_date,
+            last_modified_date=bookauthor.last_modified_date,
+            version=bookauthor.version,
+            author_id=str(bookauthor.author_id),
+            book_id=str(bookauthor.book_id)
+    )
+    return response

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

@@ -0,0 +1,23 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.bookshelf import BookshelfPublisher
+
+
+class PublisherResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+
+def to_response(publisher:  BookshelfPublisher) -> PublisherResponse:
+    response: PublisherResponse = PublisherResponse(
+            id=publisher.id,
+            created_date=publisher.created_date,
+            last_modified_date=publisher.last_modified_date,
+            version=publisher.version,
+            name=str(publisher.name)
+    )
+    return response

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

@@ -0,0 +1,35 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+from src.db.models.comic import Artist
+
+
+class ArtistCreation(BaseModel):
+    id: str
+    name: str
+
+class ArtistResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+    weblink: Optional[str]
+
+def artist_to_response(artist:  Artist) -> ArtistResponse:
+    response: ArtistResponse = ArtistResponse(
+            id=artist.id,
+            created_date=artist.created_date,
+            last_modified_date=artist.last_modified_date,
+            version=artist.version,
+            name=artist.name,
+            weblink=artist.weblink
+    )
+    return response
+
+
+class AddArtist(BaseModel):
+    id: str
+    name: str

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

@@ -0,0 +1,22 @@
+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]

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

@@ -0,0 +1,48 @@
+"""
+Schema definitions for Comics.
+"""
+from datetime import datetime
+from typing import Optional
+from pydantic import BaseModel, AnyUrl
+
+from src.db.models.comic import Comic
+
+
+class ComicResponse(BaseModel):
+    """
+    Pydantic model for returning Comic objects.
+    """
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    title: str
+    publisher_id: str
+    current_order: bool
+    completed: bool
+    weblink: Optional[str]
+
+def comic_to_response(comic:  Comic) -> ComicResponse:
+    response: ComicResponse = ComicResponse(
+            id=comic.id,
+            created_date=comic.created_date,
+            last_modified_date=comic.last_modified_date,
+            version=comic.version,
+            title=str(comic.title),
+            publisher_id=str(comic.publisher_id),
+            current_order=bool(comic.current_order),
+            completed=bool(comic.completed),
+            weblink=str(comic.weblink)
+    )
+    return response
+
+
+class ComicSchema(BaseModel):
+    """
+    Pydantic model for uploading Comic object.
+    """
+    id: str
+    title: str
+    weblink: Optional[AnyUrl]
+    completed: Optional[bool]
+    current_order: Optional[bool]

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

@@ -0,0 +1,26 @@
+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]

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

@@ -0,0 +1,32 @@
+"""
+Model definitions for ComicWork.
+"""
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.comic import ComicWork
+
+
+class ComicWorkResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    comic_id: str
+    artist_id: str
+    work_type_id: str
+
+
+def comicwork_to_response(comicwork: ComicWork) -> ComicWorkResponse:
+    response: ComicWorkResponse = ComicWorkResponse(
+        id=comicwork.id,
+        created_date=comicwork.created_date,
+        last_modified_date=comicwork.last_modified_date,
+        version=comicwork.version,
+        comic_id=str(comicwork.comic_id),
+        artist_id=str(comicwork.artist_id),
+        work_type_id=str(comicwork.work_type_id),
+    )
+    return response

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

@@ -0,0 +1,38 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+from src.db.models.comic import Issue
+
+
+class IssueResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    issue_number: str
+    title: Optional[str]
+    published_on: Optional[datetime]
+    in_stock: bool
+    is_read: bool
+    comic_id: str
+    volume_id: Optional[str]
+    story_arc_id: Optional[str]
+
+def issue_to_response(issue: Issue) -> IssueResponse:
+    response: IssueResponse = IssueResponse(
+        id=issue.id,
+        created_date=issue.created_date,
+        last_modified_date=issue.last_modified_date,
+        version=issue.version,
+        issue_number=str(issue.issue_number),
+        title=str(issue.title),
+        published_on=issue.published_on,
+        in_stock=bool(issue.in_stock),
+        is_read=bool(issue.is_read),
+        comic_id=str(issue.comic_id),
+        volume_id=str(issue.volume_id),
+        story_arc_id=str(issue.story_arc_id)
+    )
+    return response

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

@@ -0,0 +1,14 @@
+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
+

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

@@ -0,0 +1,32 @@
+"""
+Model definitions for IssueWork.
+"""
+
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.comic import IssueWork
+
+
+class IssueWorkResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    issue_id: str
+    artist_id: str
+    work_type_id: str
+
+
+def issuework_to_response(issuework: IssueWork) -> IssueWorkResponse:
+    response: IssueWorkResponse = IssueWorkResponse(
+        id=issuework.id,
+        created_date=issuework.created_date,
+        last_modified_date=issuework.last_modified_date,
+        version=issuework.version,
+        issue_id=str(issuework.issue_id),
+        artist_id=str(issuework.artist_id),
+        work_type_id=str(issuework.work_type_id),
+    )
+    return response

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

@@ -0,0 +1,30 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+from src.db.models.comic import Publisher
+
+
+class PublisherResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+    weblink: Optional[str]
+    parent_publisher_id: Optional[str]
+
+
+def publisher_to_response(publisher:  Publisher) -> PublisherResponse:
+    response: PublisherResponse = PublisherResponse(
+            id=publisher.id,
+            created_date=publisher.created_date,
+            last_modified_date=publisher.last_modified_date,
+            version=publisher.version,
+            name=str(publisher.name),
+            weblink=str(publisher.weblink),
+            parent_publisher_id=publisher.parent_publisher_id
+    )
+    return response
+

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

@@ -0,0 +1,14 @@
+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]

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

@@ -0,0 +1,30 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+from src.db.models.comic import StoryArc
+
+class StoryArcResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+    comic_id: str
+    volume_id: Optional[str]
+
+class AddLink(BaseModel):
+    url: str
+
+def storyarc_to_response(storyarc: StoryArc) -> StoryArcResponse:
+    response: StoryArcResponse = StoryArcResponse(
+        id=storyarc.id,
+        created_date=storyarc.created_date,
+        last_modified_date=storyarc.last_modified_date,
+        version=storyarc.version,
+        name=str(storyarc.name),
+        comic_id=str(storyarc.comic_id),
+        volume_id=str(storyarc.volume_id)
+    )
+    return response

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

@@ -0,0 +1,25 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.comic import Volume
+
+
+class VolumeResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+    comic_id: str
+
+def volume_to_response(volume: Volume) -> VolumeResponse:
+    response: VolumeResponse = VolumeResponse(
+        id=volume.id,
+        created_date=volume.created_date,
+        last_modified_date=volume.last_modified_date,
+        version=volume.version,
+        name=str(volume.name),
+        comic_id=str(volume.comic_id)
+    )
+    return response

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

@@ -0,0 +1,26 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.comic import WorkType
+
+class AddWorkType(BaseModel):
+    worktype: str
+
+class WorktypeResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+
+
+def worktype_to_response(worktype: WorkType) -> WorktypeResponse:
+    response: WorktypeResponse = WorktypeResponse(
+        id=worktype.id,
+        created_date=worktype.created_date,
+        last_modified_date=worktype.last_modified_date,
+        version=worktype.version,
+        name=str(worktype.name)
+    )
+    return response

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

@@ -0,0 +1,34 @@
+from datetime import datetime
+from typing import Optional
+from pydantic import BaseModel
+
+from src.db.models.media import MediaActor
+
+
+class MediaActorResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: Optional[str]
+    url: Optional[str]
+
+def actor_to_response(actor: MediaActor) -> MediaActorResponse:
+    response: MediaActorResponse = MediaActorResponse(
+        id=actor.id,
+        created_date=actor.created_date,
+        last_modified_date=actor.last_modified_date,
+        version=actor.version,
+        name=str(actor.name),
+        url=str(actor.url)        
+    )
+    return response
+
+
+class MediaActorModel(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: Optional[str]
+    url: Optional[str]

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

@@ -0,0 +1,35 @@
+from datetime import datetime
+from typing import Optional
+
+from src.db.models.media import MediaActorFile
+from pydantic import BaseModel
+
+
+class MediaActorFileResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    media_actor_id: str
+    media_file_id: Optional[str]
+
+def actorfile_to_response(actorfile:  MediaActorFile) -> MediaActorFileResponse:
+    response: MediaActorFileResponse = MediaActorFileResponse(
+            id=actorfile.id,
+            created_date=actorfile.created_date,
+            last_modified_date=actorfile.last_modified_date,
+            version=actorfile.version,
+            media_actor_id=str(actorfile.media_actor_id),
+            media_file_id=str(actorfile.media_file_id)
+    )
+    return response
+
+
+class MediaActorFileModel(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    media_actor_id: str
+    media_file_id: Optional[str]
+    

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

@@ -0,0 +1,30 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+from src.db.models.media import MediaArticle
+
+class MediaArticleResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    review: bool = False
+    title: Optional[str] = None
+    url: Optional[str] = None
+
+class AddLink(BaseModel):
+    url: str
+
+def to_response(video: MediaArticle) -> MediaArticleResponse:
+    response: MediaArticleResponse = MediaArticleResponse(
+        id=video.id,
+        created_date=video.created_date,
+        last_modified_date=video.last_modified_date,
+        version=video.version,
+        review=bool(video.review),
+        title=str(video.title),
+        url=str(video.url),
+    )
+    return response

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

@@ -0,0 +1,81 @@
+from datetime import datetime
+from typing import Optional
+
+from src.db.models.media import MediaFile
+from pydantic import BaseModel
+
+
+class MediaFileResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    title: Optional[str]
+    file_name: Optional[str]
+    cloud_link: Optional[str]
+    url: Optional[str]
+    review: bool = False
+    should_download: bool = False
+
+
+def file_to_response(mediafile: MediaFile) -> MediaFileResponse:
+    """
+    Create MediaFileResponse from model.
+    """
+    response: MediaFileResponse = MediaFileResponse(
+        id=mediafile.id,
+        created_date=mediafile.created_date,
+        last_modified_date=mediafile.last_modified_date,
+        version=mediafile.version,
+        title=mediafile.title,
+        file_name=mediafile.file_name,
+        cloud_link=mediafile.cloud_link,
+        url=mediafile.url,
+        review=mediafile.review,
+        should_download=mediafile.should_download,
+    )
+    return response
+
+
+def file_to_model(model: MediaFileResponse, mediafile: MediaFile) -> MediaFile:
+    """
+    Set data of response to model.
+    """
+    mediafile.file_name = model.file_name
+    mediafile.cloud_link = model.cloud_link
+    if model.url is not None:
+        mediafile.url = model.url
+    else:
+        mediafile.url = ""
+    if model.title is not None:
+        mediafile.title = model.title
+    else:
+        mediafile.title = ""
+    mediafile.last_modified_date = datetime.now()
+    mediafile.review = model.review
+    mediafile.should_download = model.should_download
+    return mediafile
+
+
+class MediaFileModel(BaseModel):
+    """
+    Pydantic model to import MediaFile.
+    """
+    id: str
+    created_date: Optional[datetime]
+    last_modified_date: Optional[datetime]
+    version: int = 0
+    title: Optional[str]
+    file_name: Optional[str]
+    cloud_link: Optional[str]
+    url: Optional[str]
+    review: bool = True
+    should_download: bool = True
+    
+
+class Link(BaseModel):
+    """
+    PYdantic model for uploading url.
+    """
+
+    url: str

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

@@ -0,0 +1,67 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.media import MediaLofi
+
+class MediaLofiResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    title: str = ""
+    file_name: str = ""
+    url: str = ""
+    review: bool = False
+    should_download: bool = False
+
+class AddLofi(BaseModel):
+    url: str
+
+class MediaLofiModel(BaseModel):
+    """
+    Pydantic Model to import MediaLofi.
+    """
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int = 0
+    title: str = ""
+    file_name: str = ""
+    url: str = ""
+    review: bool = False
+    should_download: bool = False
+    
+
+def lofi_to_model(model: MediaLofiResponse, medialofi: MediaLofi) -> MediaLofi:
+    """
+    Set data of response to model
+    """
+    medialofi.file_name = model.file_name
+    if model.url is not None:
+        medialofi.url = model.url
+    else:
+        medialofi.url = ""
+    if model.title is not None:
+        medialofi.title = model.title
+    else:
+        medialofi.title = ""
+    medialofi.last_modified_date = datetime.now()
+    medialofi.review = model.review
+    medialofi.should_download = model.should_download
+    return medialofi
+
+    
+def lofi_to_response(lofi: MediaLofi) -> MediaLofiResponse:
+    response: MediaLofiResponse = MediaLofiResponse(
+        id=lofi.id,
+        created_date=lofi.created_date,
+        last_modified_date=lofi.last_modified_date,
+        version=lofi.version,
+        file_name=str(lofi.file_name),
+        review=bool(lofi.review),
+        should_download=bool(lofi.should_download),
+        title=str(lofi.title),
+        url=str(lofi.url),
+    )
+    return response

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

@@ -0,0 +1,38 @@
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel
+
+from src.db.models.media import MediaVideo
+
+class MediaVideoResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    cloud_link: Optional[str] = None
+    file_name: Optional[str] = None
+    path: Optional[str] = None
+    review: bool = False
+    title: Optional[str] = None
+    url: Optional[str] = None
+    should_download: bool = False
+
+class AddLink(BaseModel):
+    url: str
+
+def video_to_response(video: MediaVideo) -> MediaVideoResponse:
+    response: MediaVideoResponse = MediaVideoResponse(
+        id=video.id,
+        created_date=video.created_date,
+        last_modified_date=video.last_modified_date,
+        version=video.version,
+        cloud_link=str(video.cloud_link),
+        file_name=str(video.file_name),
+        path=str(video.path),
+        review=bool(video.review),
+        title=str(video.title),
+        url=str(video.url),
+        should_download=bool(video.should_download)
+    )
+    return response

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

@@ -0,0 +1,31 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.tysc import Card
+
+
+class CardResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    card_number: int
+    year: int
+    card_set_id: str
+    rooster_id: str
+    vendor_id: str
+
+def to_response(card: Card) -> CardResponse:
+    response: CardResponse = CardResponse(
+            id=card.id,
+            created_date=card.created_date,
+            last_modified_date=card.last_modified_date,
+            version=card.version,
+            card_number=card.card_number,
+            year=card.year,
+            card_set_id=str(card.card_set_id),
+            rooster_id=str(card.rooster_id),
+            vendor_id=str(card.vendor_id)
+    )
+    return response

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

@@ -0,0 +1,30 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.tysc import CardSet
+
+
+class CardSetResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+    parallel_set: bool
+    insert_set: bool
+    vendor_id: str
+
+
+def to_response(cardset: CardSet) -> CardSetResponse:
+    response: CardSetResponse = CardSetResponse(
+            id=cardset.id,
+            created_date=cardset.created_date,
+            last_modified_date=cardset.last_modified_date,
+            version=cardset.version,
+            name=str(cardset.name),
+            parallel_set=bool(cardset.parallel_set),
+            insert_set=bool(cardset.insert_set),
+            vendor_id=str(cardset.vendor_id)
+    )
+    return response

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

@@ -0,0 +1,28 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.tysc import FieldPosition
+
+
+class FieldPositionResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+    short_name: str
+    sport_id: str
+
+
+def to_response(fieldposition: FieldPosition) -> FieldPositionResponse:
+    response: FieldPositionResponse = FieldPositionResponse(
+        id=fieldposition.id,
+        created_date=fieldposition.created_date,
+        last_modified_date=fieldposition.last_modified_date,
+        version=fieldposition.version,
+        name=str(fieldposition.name),
+        short_name=str(fieldposition.short_name),
+        sport_id=str(fieldposition.sport_id)
+    )
+    return response

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

@@ -0,0 +1,25 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.tysc import Player
+
+
+class PlayerResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    first_name: str
+    last_name: str
+
+def to_response(player: Player) -> PlayerResponse:
+    response: PlayerResponse = PlayerResponse(
+            id=player.id,
+            created_date=player.created_date,
+            last_modified_date=player.last_modified_date,
+            version=player.version,
+            first_name=str(player.first_name),
+            last_name=str(player.last_name)
+    )
+    return response

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

@@ -0,0 +1,36 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.tysc import Rooster
+
+
+class RoosterResponse(BaseModel):
+    """
+    Pydantic model for returning Rooster objects.
+    """
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    year: int
+    team_id: str
+    player_id: str
+    position_id: str
+
+
+def to_response(rooster: Rooster) -> RoosterResponse:
+    """
+    convert database object to response object (Pydantic).
+    """
+    response: RoosterResponse = RoosterResponse(
+        id=rooster.id,
+        created_date=rooster.created_date,
+        last_modified_date=rooster.last_modified_date,
+        version=rooster.version,
+        year=rooster.year,
+        team_id=str(rooster.team_id),
+        player_id=str(rooster.player_id),
+        position_id=str(rooster.position_id)
+    )
+    return response

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

@@ -0,0 +1,24 @@
+
+from datetime import datetime
+from pydantic import BaseModel
+
+from src.db.models.tysc import Sport
+
+
+class SportResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+
+
+def to_response(sport: Sport) -> SportResponse:
+    response: SportResponse = SportResponse(
+        id=sport.id,
+        created_date=sport.created_date,
+        last_modified_date=sport.last_modified_date,
+        version=sport.version,
+        name=str(sport.name)
+    )
+    return response

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

@@ -0,0 +1,28 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.tysc import Team
+
+
+class TeamResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+    short_name: str
+    sport_id: str
+
+
+def to_response(team: Team) -> TeamResponse:
+    response: TeamResponse = TeamResponse(
+        id=team.id,
+        created_date=team.created_date,
+        last_modified_date=team.last_modified_date,
+        version=team.version,
+        name=str(team.name),
+        short_name=str(team.short_name),
+        sport_id=str(team.sport_id)
+    )
+    return response

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

@@ -0,0 +1,32 @@
+"""
+class and function for json response objects for Vendor.
+"""
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.tysc import Vendor
+
+
+class VendorResponse(BaseModel):
+    """
+    Pydantic model for Vendor reponse object.
+    """
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+
+def to_response(vendor: Vendor) -> VendorResponse:
+    """
+    convert database object Vendor to response object VendorResponse.
+    """
+    reponse: VendorResponse = VendorResponse(
+        id=vendor.id,
+        created_date=vendor.created_date,
+        last_modified_date=vendor.last_modified_date,
+        version=vendor.version,
+        name=str(vendor.name)
+    )
+    return reponse

kontor-api/src/schema/user/assignment.py

@@ -0,0 +1,26 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.admin import Assignment
+
+
+class AssignmentResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    profile_id: str
+    permission_id: str
+
+
+def to_response(assignment: Assignment) -> AssignmentResponse:
+    response: AssignmentResponse = AssignmentResponse(
+        id=assignment.id,
+        created_date=assignment.created_date,
+        last_modified_date=assignment.last_modified_date,
+        version=assignment.version,
+        profile_id=str(assignment.profile_id),
+        permission_id=str(assignment.permission_id)
+    )
+    return response

kontor-api/src/schema/user/permission.py

@@ -0,0 +1,24 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.admin import Permission
+
+
+class PermissionResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    name: str
+
+
+def to_response(permission: Permission) -> PermissionResponse:
+    response: PermissionResponse = PermissionResponse(
+        id=permission.id,
+        created_date=permission.created_date,
+        last_modified_date=permission.last_modified_date,
+        version=permission.version,
+        name=str(permission.name)
+    )
+    return response

kontor-api/src/schema/user/profile.py

@@ -0,0 +1,50 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.admin import Profile
+
+
+class ProfileResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    first_name: str
+    last_name: str
+    user_name: str
+    email: str
+    password: str
+    enabled: bool
+
+def to_response(profile: Profile) -> ProfileResponse:
+    response: ProfileResponse = ProfileResponse(
+        id=profile.id,
+        created_date=profile.created_date,
+        last_modified_date=profile.last_modified_date,
+        version=profile.version,
+        first_name=str(profile.first_name),
+        last_name=str(profile.last_name),
+        user_name=str(profile.user_name),
+        email=str(profile.email),
+        password=str(profile.password),
+        enabled=bool(profile.enabled)
+    )
+    return response
+
+class ProfileModel(BaseModel):
+    username: str
+    email: str
+    first_name: str
+    last_name: str
+    active: bool
+
+def to_model(profile: Profile) -> ProfileModel:
+    model: ProfileModel = ProfileModel(
+        username=profile.user_name,
+        email=profile.email,
+        first_name=profile.first_name,
+        last_name=profile.last_name,
+        active=profile.enabled,
+    )
+    return model

kontor-api/src/schema/user/token.py

@@ -0,0 +1,32 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+from src.db.models.admin import Token
+
+
+class TokenResponse(BaseModel):
+    id: str
+    created_date: datetime
+    last_modified_date: datetime
+    version: int
+    token: str
+    name: str
+    last_used_date: datetime
+    enabled: bool
+    profile_id: str
+
+
+def to_response(token: Token) -> TokenResponse:
+    response: TokenResponse = TokenResponse(
+        id=token.id,
+        created_date=token.created_date,
+        last_modified_date=token.last_modified_date,
+        version=token.version,
+        token=str(token.token),
+        name=str(token.name),
+        last_used_date=token.last_used_date,
+        enabled=bool(token.enabled),
+        profile_id=str(token.profile_id)
+    )
+    return response