import sources from develop/0.1.0

kontor-api/src/apis/base.py

@@ -0,0 +1,8 @@
+from fastapi import APIRouter
+
+from src.apis.version1 import comic, media, tysc
+
+api_router =  APIRouter(prefix="/api")
+api_router.include_router(comic.router, prefix="/comics", tags=["comics"])
+api_router.include_router(media.router, prefix="/media", tags=["media"])
+api_router.include_router(tysc.router, prefix="/tysc", tags=["tysc"])

kontor-api/src/apis/utils.py

@@ -0,0 +1,8 @@
+from typing import Annotated
+
+from fastapi import Depends
+from sqlalchemy.orm import Session
+
+from src.db.session import get_db
+
+SessionDep = Annotated[Session, Depends(get_db)]

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

@@ -0,0 +1,62 @@
+from uuid import UUID
+from typing import List
+from fastapi import APIRouter, HTTPException, status
+from sqlalchemy import select
+
+from src.apis.utils import SessionDep
+from src.schema.comics.comic import ComicResponse, ComicDetailsResponse, get_comic_details, get_short_info
+from src.schema.comics.artist import ArtistCreation, ArtistDetailResponse, ArtistResponse, get_artist_details
+from src.db.models.comic import Comic, Artist
+
+router = APIRouter(
+    prefix="/comic",
+    tags=["comics"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+@router.get("/comics")
+def get_all_comics(db: SessionDep) -> List[ComicResponse]:
+    results: List[ComicResponse] = []
+    comics = db.scalars(select(Comic)).all()
+    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: UUID, db: SessionDep) -> ComicDetailsResponse:
+    comic = db.get(Comic, comic_id)
+    if comic is None:
+        raise HTTPException(status_code=404, detail="Comic could not be found")
+    response: ComicDetailsResponse = get_comic_details(comic)
+    return response
+
+@router.get("/artists", response_model=List[ArtistResponse])
+def get_all_artists(db: SessionDep) -> List[ArtistResponse]:
+    results: List[ArtistResponse] = []
+    artists = db.query(Artist).all()
+    for artist in artists:
+        results.append(ArtistResponse(id=artist.id, name=artist.name))
+    return results
+
+@router.get("/artists/{artist_id}", response_model=ArtistDetailResponse)
+def get_artist(artist_id: UUID, db: SessionDep) -> ArtistDetailResponse:
+    artist = db.get(Artist, artist_id)
+    if artist is None:
+        raise HTTPException(status_code=404, detail="Artist could not be found")
+    response: ArtistDetailResponse = get_artist_details(artist)
+    return response
+
+@router.post("/artists", status_code=status.HTTP_201_CREATED)
+def add_artist(db: SessionDep, artist_creation: ArtistCreation) -> ArtistResponse:
+    artist: Artist = Artist()
+    setattr(artist, "name", artist_creation.name)
+    try:
+        db.add(artist)
+        db.commit()
+    except:
+        raise HTTPException(status_code=409, detail="Artist already added")
+    response = ArtistResponse(id=artist.id, name=artist.name)
+    return response
+

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

@@ -0,0 +1,76 @@
+from typing import List
+from uuid import UUID
+
+from fastapi import APIRouter, status, HTTPException
+from sqlalchemy import select, Sequence
+
+from src.apis.utils import SessionDep
+from src.schema.media.file import MediaFileResponse, Link, get_file_details, set_file
+from src.db.models.media import MediaFile
+
+router = APIRouter(
+    prefix="/media",
+    tags=["media"]
+)
+
+@router.get("/update-titles")
+def update_titles(db: SessionDep) -> list[MediaFileResponse]:
+    results: list[MediaFileResponse] = []
+    files = db.query(MediaFile).filter(MediaFile.review == 1).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) -> List[MediaFileResponse]:
+    results: list[MediaFileResponse] = []
+    files: Sequence[MediaFile]
+    if review:
+        files = db.query(MediaFile).filter(MediaFile.review == 1).all()
+    elif download:
+        files = db.query(MediaFile).filter(MediaFile.should_download == 1).all()
+    else:
+        files = db.scalars(select(MediaFile)).all()
+    for mediafile in files:
+        response = get_file_details(mediafile)
+        results.append(response)
+    return results
+
+@router.get("/files/{file_id}", response_model=MediaFileResponse)
+def get_file(file_id: UUID, db: SessionDep) -> MediaFileResponse:
+    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.put("/files/{file_id}", response_model=MediaFileResponse)
+def update_file(file_id: UUID, db: SessionDep, info: MediaFileResponse) -> MediaFileResponse:
+    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()
+    return info
+
+
+@router.post("/files", status_code=status.HTTP_201_CREATED)
+def add_file(new_link: Link, db: SessionDep) -> MediaFileResponse:
+    print(new_link.url)
+    try:
+        mediaFile: MediaFile = MediaFile()
+        setattr(mediaFile, "url", new_link.url)
+        setattr(mediaFile, "review", 1)
+        setattr(mediaFile, "should_download", 1)
+        db.add(mediaFile)
+        db.commit()
+    except:
+        raise HTTPException(status_code=409, detail="Link duplicate")
+    response = get_file_details(mediaFile)
+    return response

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

@@ -0,0 +1,20 @@
+from typing import List
+from fastapi import APIRouter
+
+from src.apis.utils import SessionDep
+from src.schema.tysc.sport import SportResponse
+from src.db.models.tysc import Sport
+
+router = APIRouter(
+    prefix="/tysc",
+    tags=["tysc"],
+    responses={404: {"description": "Not found"}},
+)
+
+@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

kontor-api/src/core/config.py

@@ -0,0 +1,23 @@
+import os
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+env_path = Path(".") / ".env"
+load_dotenv(dotenv_path=env_path)
+
+
+class Settings:
+    PROJECT_NAME: str = "Kontor"
+    PROJECT_VERSION: str = "0.1.0"
+
+    MARIADB_USER: str = os.getenv("MARIADB_USER", "kontor")
+    MARIADB_PASSWORD: str = os.getenv("MARIADB_PASSWORD", "kontor")
+    MARIADB_SERVER: str = os.getenv("MARIADB_SERVER", "mariadb")
+    MARIADB_PORT: str = os.getenv("MARIADB_PORT", 3306)
+    MARIADB_DB: str = os.getenv("MARIADB_DB", "kontor")
+    DATABASE_URL: str = f"mariadb+mariadbconnector://{MARIADB_USER}:{MARIADB_PASSWORD}@{MARIADB_SERVER}:{MARIADB_PORT}/{MARIADB_DB}"
+
+
+settings = Settings()
+

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

@@ -0,0 +1,78 @@
+from datetime import datetime
+
+from sqlalchemy import Column, ForeignKey, Integer, String
+from sqlalchemy.dialects.mysql import BIT
+from sqlalchemy.orm import relationship, mapped_column, Mapped
+
+from src.db.models.base import Base, BaseMixin
+
+
+class User(Base, BaseMixin):
+    __tablename__ = 'user'
+    first_name = Column(String(255))
+    last_name = Column(String(255))
+    user_name = Column(String(255), nullable=False)
+    email = Column(String(255))
+    password = Column(String(255))
+    enabled = Column(BIT(1))
+    matrix = relationship("AuthorizationMatrix")
+    tokens = relationship("Token")
+
+    def get_full_name(self) -> str:
+        full_name = ""
+        if self.first_name is not None:
+            full_name += self.first_name
+        if self.last_name is not None:
+            if len(full_name) > 0:
+                full_name += " "
+            full_name += self.last_name
+        return full_name
+
+
+class Token(Base, BaseMixin):
+    __tablename__ = "token"
+    token = Column(String(255), nullable=False, unique=True)
+    name = Column(String(255))
+    last_used_date: Mapped[datetime] = mapped_column()
+    enabled = Column(BIT(1))
+    user_id = Column(String(255), ForeignKey("user.id"), nullable=False)
+    user = relationship("User", back_populates="tokens")
+
+
+class Role(Base, BaseMixin):
+    __tablename__ = "role"
+    name = Column(String(255), nullable=False)
+    matrix = relationship("AuthorizationMatrix")
+
+
+class AuthorizationMatrix(Base, BaseMixin):
+    __tablename__ = "authorization_matrix"
+    user_id = Column(String, ForeignKey("user.id"), nullable=False)
+    user = relationship("User", back_populates="matrix")
+    role_id = Column(String, ForeignKey("role.id"), nullable=False)
+    role = relationship("Role", back_populates="matrix")
+
+
+class ModuleData(Base, BaseMixin):
+    __tablename__ = "module_data"
+    module_name = Column(String(255), nullable=False)
+    import_data = Column(BIT(1))
+
+
+class MailAccount(Base, BaseMixin):
+    __tablename__ = "mail_account"
+    host = Column(String(255))
+    port = Column(Integer)
+    protocol = Column(String(255))
+    user_name = Column(String(255))
+    password = Column(String(255))
+    start_tls = Column(BIT(1))
+
+
+class Mail(Base, BaseMixin):
+    __tablename__ = "mail"
+    folder: Mapped[str] = mapped_column()
+    subject: Mapped[str] = mapped_column()
+    body: Mapped[str] = mapped_column()
+    sent_date: Mapped[datetime] = mapped_column()
+    received_date: Mapped[datetime] = mapped_column()

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

@@ -0,0 +1,31 @@
+import uuid
+from datetime import datetime
+
+from sqlalchemy import func, Column, String
+from sqlalchemy.dialects.mysql import BIT
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+
+class Base(DeclarativeBase):
+    pass
+
+
+class BaseMixin:
+    id = Column(String(255), primary_key=True, default=uuid.uuid4())
+    # id: Mapped[str] = mapped_column(primary_key=True, default=uuid.uuid4())
+    # created_date = Column(DateTime)
+    created_date: Mapped[datetime] = mapped_column(default=func.now())
+    # last_modified_date = Column(DateTime)
+    last_modified_date: Mapped[datetime] = mapped_column(default=func.now())
+    # version = Column(Integer)
+    version: Mapped[int] = mapped_column(default=0)
+
+
+class BaseVideoMixin:
+    cloud_link = Column(String(255))
+    file_name = Column(String(255))
+    path = Column(String(255))
+    review = Column(BIT(1))
+    title = Column(String(255))
+    url = Column(String(255), unique=True)
+    should_download = Column(BIT(1))

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

@@ -0,0 +1,50 @@
+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(length=255), unique=True)
+    article_authors = relationship("ArticleAuthor")
+
+
+class Author(Base, BaseMixin):
+    __tablename__ = 'author'
+    first_name = Column(String(255))
+    last_name = Column(String(255))
+    article_authors = relationship("ArticleAuthor")
+    book_authors = relationship("BookAuthor")
+
+
+class BookshelfPublisher(Base, BaseMixin):
+    __tablename__ = 'bookshelf_publisher'
+    name = Column(String(length=255), unique=True)
+    books = relationship("Book")
+
+
+class Book(Base, BaseMixin):
+    __tablename__ = 'book'
+    isbn = Column(String(255), unique=True)
+    title = Column(String(255))
+    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")

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

@@ -0,0 +1,128 @@
+from typing import Dict, List
+from natsort import natsorted
+from sqlalchemy import Column, ForeignKey, Integer, String
+from sqlalchemy.dialects.mysql import BIT
+from sqlalchemy.orm import relationship
+
+from src.db.models.base import Base, BaseMixin
+
+
+class Publisher(Base, BaseMixin):
+    __tablename__ = "publisher"
+    name = Column(String(length=255), unique=True)
+    comics = relationship("Comic")
+
+    def __repr__(self):
+        return f'Publisher({self.id} {self.name})'
+
+    def __str__(self):
+        return self.__repr__()
+
+
+class Comic(Base, BaseMixin):
+    __tablename__ = 'comic'
+    title = Column(String(length=255), unique=True)
+    publisher_id = Column(String, ForeignKey('publisher.id'), nullable=False)
+    publisher = relationship("Publisher", back_populates="comics")
+    current_order = Column(BIT(1))
+    completed = Column(BIT(1))
+    issues = relationship("Issue", order_by="Issue.issue_number")
+    story_arcs = relationship("StoryArc")
+    trade_paperbacks = relationship("TradePaperback")
+    volumes = relationship("Volume")
+    comic_works = relationship("ComicWork")
+
+    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[str, List[str]]:
+        works: Dict[str, List[str]] = {}
+        for work in self.comic_works:
+            work_type = work.work_type.name
+            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 = Column(String(length=255), nullable=False)
+    comic_id = Column(String, ForeignKey("comic.id"), nullable=False)
+    comic = relationship("Comic", back_populates="volumes")
+    issues = relationship("Issue")
+
+
+class TradePaperback(Base, BaseMixin):
+    __tablename__ = "trade_paperback"
+    name = Column(String(length=255), nullable=False)
+    issue_start = Column(Integer)
+    issue_end = Column(Integer)
+    comic_id = Column(String, ForeignKey("comic.id"), nullable=False)
+    comic = relationship("Comic", back_populates="trade_paperbacks")
+
+
+class StoryArc(Base, BaseMixin):
+    __tablename__ = "story_arc"
+    name = Column(String(length=255), nullable=False)
+    comic_id = Column(String, ForeignKey("comic.id"), nullable=False)
+    comic = relationship("Comic", back_populates="story_arcs")
+
+
+class Issue(Base, BaseMixin):
+    __tablename__ = "issue"
+    issue_number = Column(String(255))
+    in_stock = Column(BIT(1))
+    is_read = Column(BIT(1))
+    comic_id = Column(String, ForeignKey("comic.id"), nullable=False)
+    comic = relationship("Comic", back_populates="issues")
+    volume_id = Column(String, ForeignKey("volume.id"), nullable=True)
+    volume = relationship("Volume", back_populates="issues")
+
+
+class Artist(Base, BaseMixin):
+    __tablename__ = "artist"
+    name = Column(String(length=255), nullable=False)
+    comic_works = relationship("ComicWork")
+
+    def get_comics(self) -> Dict[str, List[str]]:
+        works: Dict[str, List[str]] = {}
+        for work in self.comic_works:
+            work_type = work.work_type.name
+            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 = Column(String(length=255), nullable=False, unique=True)
+    comic_works = relationship("ComicWork")
+
+    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 = Column(String, ForeignKey("comic.id"), nullable=False)
+    comic = relationship("Comic", back_populates="comic_works")
+    artist_id = Column(String, ForeignKey("artist.id"), nullable=False)
+    artist = relationship("Artist", back_populates="comic_works")
+    work_type_id = Column(String, ForeignKey("worktype.id"), nullable=False)
+    work_type = relationship("WorkType", back_populates="comic_works")

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

@@ -0,0 +1,396 @@
+import json
+import logging
+import uuid
+from datetime import datetime
+from enum import Enum, auto
+from pathlib import Path
+from typing import Any
+
+from sqlalchemy import select
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.orm import sessionmaker
+
+from src.db.models.tysc import Card, CardSet, Rooster, Team, FieldPosition, Player, Vendor, Sport
+from src.db.models.comic import Issue, TradePaperback, StoryArc, Volume, ComicWork, Artist, Comic, Publisher, WorkType
+from src.db.models.bookshelf import ArticleAuthor, BookAuthor, BookshelfPublisher, Article, Book, Author
+from src.db.models.admin import Mail, MailAccount, ModuleData, Role, User, Token, AuthorizationMatrix
+from src.db.models.metadata import MetaDataTable, MetaDataColumn
+from src.db.models.media import MediaVideo, MediaArticle, MediaFile, MediaActor, MediaActorFile
+
+
+class ColumnEntry(Enum):
+    COLUMN_NAME = 'column'
+    COLUMN_LABEL = 'label'
+    COLUMN_ORDER = 'order'
+    COLUMN_REF_COLUMN = 'ref_column'
+    COLUMN_TYPE = 'type'
+    COLUMN_WIDGET = 'widget'
+
+
+class StatusType(Enum):
+    UNKNOWN = auto()
+    FILE_NAME = auto()
+    FILE_ID = auto()
+    DUPLICATE = auto()
+    CLOUD_LINK = auto()
+    CLOUD_LINK_ID = auto()
+
+class ExportType(Enum):
+    JSON = "JSON"
+    YAML = "YAML"
+    SQLITE = "SQLite"
+
+
+class KontorDB:
+
+    def __init__(self, db_engine: Any):
+        self.engine = db_engine
+        self.registry = {}
+        self.init_registry()
+
+    def init_registry(self):
+        self.registry[Card.__tablename__] = Card
+        self.registry[CardSet.__tablename__] = CardSet
+        self.registry[Rooster.__tablename__] = Rooster
+        self.registry[Team.__tablename__] = Team
+        self.registry[FieldPosition.__tablename__] = FieldPosition
+        self.registry[Player.__tablename__] = Player
+        self.registry[Vendor.__tablename__] = Vendor
+        self.registry[Sport.__tablename__] = Sport
+        self.registry[Issue.__tablename__] = Issue
+        self.registry[TradePaperback.__tablename__] = TradePaperback
+        self.registry[StoryArc.__tablename__] = StoryArc
+        self.registry[Volume.__tablename__] = Volume
+        self.registry[ComicWork.__tablename__] = ComicWork
+        self.registry[Artist.__tablename__] = Artist
+        self.registry[Comic.__tablename__] = Comic
+        self.registry[Publisher.__tablename__] = Publisher
+        self.registry[WorkType.__tablename__] = WorkType
+        self.registry[ArticleAuthor.__tablename__] = ArticleAuthor
+        self.registry[BookAuthor.__tablename__] = BookAuthor
+        self.registry[BookshelfPublisher.__tablename__] = BookshelfPublisher
+        self.registry[Article.__tablename__] = Article
+        self.registry[Book.__tablename__] = Book
+        self.registry[Author.__tablename__] = Author
+        self.registry[MediaFile.__tablename__] = MediaFile
+        self.registry[MediaActor.__tablename__] = MediaActor
+        self.registry[MediaActorFile.__tablename__] = MediaActorFile
+        self.registry[MediaArticle.__tablename__] = MediaArticle
+        self.registry[MediaVideo.__tablename__] = MediaVideo
+        self.registry[MetaDataColumn.__tablename__] = MetaDataColumn
+        self.registry[MetaDataTable.__tablename__] = MetaDataTable
+        self.registry[AuthorizationMatrix.__tablename__] = AuthorizationMatrix
+        self.registry[Token.__tablename__] = Token
+        self.registry[User.__tablename__] = User
+        self.registry[Role.__tablename__] = Role
+        self.registry[ModuleData.__tablename__] = ModuleData
+        self.registry[MailAccount.__tablename__] = MailAccount
+        self.registry[Mail.__tablename__] = Mail
+
+    def get_table_names(self) -> list:
+        result = []
+        __session__ = sessionmaker(self.engine)
+        with __session__() as session:
+            tables = session.scalars(select(MetaDataTable)).all()
+            result = [table.table_name for table in tables]
+        return result
+
+    def get_table_by_name(self, table_name: str) -> dict:
+        result = {}
+        __session__ = sessionmaker(self.engine)
+        _filter = {'table_name': table_name}
+        with __session__() as session:
+            table = session.query(MetaDataTable).filter_by(**_filter).one()
+            result['id'] = table.id
+            result['table_name'] = table.table_name
+        return result
+
+    def get_column_meta_data(self, table_name: str, view_only=True) -> dict:
+        meta_data = {}
+        order = 0
+        __session__ = sessionmaker(self.engine)
+        columns = list()
+        table_info = self.get_table_by_name(table_name)
+        _filters = {'table_id': table_info['id']}
+        if view_only:
+            _filters['is_shown'] = True
+        with __session__() as session:
+            columns = session.query(MetaDataColumn).filter_by(**_filters).all()
+        for column in columns:
+            # self.log.info("get_column_meta_data: %s %s %d", column.column_name, column.column_label, column.column_order)
+            meta_data[order] = {
+                ColumnEntry.COLUMN_NAME: column.column_name,
+                ColumnEntry.COLUMN_LABEL: column.column_label,
+                ColumnEntry.COLUMN_ORDER: column.column_order,
+                ColumnEntry.COLUMN_REF_COLUMN: column.ref_column,
+                ColumnEntry.COLUMN_TYPE: column.column_type
+            }
+            order += 1
+        return meta_data
+
+    def get_columns(self, table_name: str) -> dict:
+        columns = {}
+        __session__ = sessionmaker(self.engine)
+        table_info = self.get_table_by_name(table_name)
+        _filters = {'table_id': table_info['id']}
+        with __session__() as session:
+            for column in session.query(MetaDataColumn).filter_by(**_filters).all():
+                columns[column.column_name] = {
+                    ColumnEntry.COLUMN_ORDER: column.column_order,
+                    ColumnEntry.COLUMN_TYPE: column.column_type
+                }
+        return columns
+
+    def get_filters(self, table_name: str) -> dict:
+        _filter_map = {}
+        __session__ = sessionmaker(self.engine)
+        table_info = self.get_table_by_name(table_name)
+        _filters = {'table_id': table_info['id'], 'show_filter': True}
+        with __session__() as session:
+            for column in session.query(MetaDataColumn).filter_by(**_filters).all():
+                _filter_map[column.column_name] = {
+                    ColumnEntry.COLUMN_LABEL: column.filter_label,
+                    ColumnEntry.COLUMN_WIDGET: None
+                }
+        return _filter_map
+
+    def data(self, table_name: str, columns: dict, filters: dict) -> list:
+        data = []
+        __session__ = sessionmaker(self.engine)
+        table = self.registry[table_name]
+        with __session__() as session:
+            entries = []
+            if len(filters) == 0:
+                entries = session.scalars(select(table)).all()
+            else:
+                entries = session.scalars(select(table).filter_by(**filters)).all()
+            for entry in entries:
+                # self.log.info("data: %s", entry)
+                row = []
+                for order in columns.keys():
+                    column_name = columns[order][ColumnEntry.COLUMN_NAME]
+                    ref_column = columns[order][ColumnEntry.COLUMN_REF_COLUMN]
+                    if str(column_name).endswith("_id"):
+                        ref_table = column_name[:-3]
+                        ref = getattr(entry, ref_table)
+                        value = getattr(ref, ref_column)
+                        row.append(value)
+                    else:
+                        row.append(getattr(entry, column_name))
+                data.append(row)
+        # self.log.info("data: %s", data)
+        return data
+
+    def export_db(self, export_type: str, export_file_name: str) -> dict:
+        results = {}
+        db = {}
+        export_table_list = self.get_table_names()
+        for table in export_table_list:
+            columns = self.get_column_meta_data(table, view_only=False)
+            if table in self.registry:
+                model = self.registry[table]
+            else:
+                logging.info(f"table {table} is not registered")
+                continue
+            __session__ = sessionmaker(self.engine)
+            with __session__() as session:
+                rows = session.query(model).all()
+                entries = []
+                for row in rows:
+                    # print(row)
+                    entry = {}
+                    for order in columns:
+                        # print(columns[order])
+                        column_name = columns[order][ColumnEntry.COLUMN_NAME]
+                        # print(f"get value {column_name} from {row} of table {table}")
+                        try:
+                            value = getattr(row, column_name)
+                            if isinstance(value, datetime):
+                                entry[column_name] = str(value)
+                            else:
+                                entry[column_name] = value
+                        except AttributeError:
+                            pass
+                    entries.append(entry)
+                db[table] = entries
+                results[table] = len(entries)
+        match export_type:
+            case "JSON":
+                json_dump = json.dumps(db, indent=4)
+                with open(export_file_name, "w") as dump_file:
+                    dump_file.write(json_dump)
+            case "YAML":
+                pass
+            case "SQLite":
+                pass
+        logging.info(f"{len(results)} tables exported")
+        return results
+
+    def import_db(self, import_file_name: str) -> dict:
+        result = {}
+        import_file = Path(import_file_name)
+        if not import_file.exists():
+            logging.info(f"File {import_file_name} does not exist. Do nothing.")
+            return result
+        match import_file.suffix:
+            case '.json':
+                print("read json file")
+                with open(import_file_name, 'r') as json_file:
+                    json_load = json.load(json_file)
+                for table in json_load:
+                    logging.info(f"{table}: {len(json_load[table])}")
+                    result[table] = self.import_table(table, json_load[table])
+            case '.yml':
+                print("read yaml file")
+            case '.yaml':
+                print("read yaml file")
+            case '.db':
+                print("read sqlite file")
+        return result
+
+    def import_table(self, table_name: str, items:list) -> dict:
+        result = {}
+        updated = []
+        added = []
+        remaining = []
+        existing_ids = self.get_ids(table_name)
+        logging.info(f"found {len(existing_ids)} existing ids for table {table_name}")
+        for item in items:
+            current_id = item['id']
+            # print(f"import item: {item}")
+            found_item = None
+            __session__ = sessionmaker(self.engine)
+            with __session__() as session:
+                found_item = session.get(self.registry[table_name], current_id)
+                # print(f"found item: {found_item}")
+            if found_item is not None:
+                changed = self.update_entry(table_name, current_id, item)
+                updated.append(item)
+                if changed:
+                    logging.info(f"{current_id} has changed")
+                    updated.append(item)
+                existing_ids.remove(current_id)
+            else:
+                try:
+                    self.add_entry(table_name, item)
+                    added.append(item)
+                except IntegrityError as error:
+                    logging.info(f"Could not add item, due to: {error.detail}")
+        if len(existing_ids) > 0:
+            print(f"remaining items for {table_name}: {existing_ids}")
+            remaining.extend(existing_ids)
+        result['updated'] = updated
+        result['added'] = added
+        result['remaining'] = remaining
+        return result
+
+    def get_ids(self, table_name: str) -> list:
+        existing_ids = []
+        __session__ = sessionmaker(self.engine)
+        with __session__() as session:
+            items = session.query(self.registry[table_name]).all()
+            for item in items:
+                existing_ids.append(getattr(item, 'id'))
+        return existing_ids
+
+    def add_entry(self, table_name: str, update_item: dict):
+        logging.debug(f"add entry to table {table_name} with {update_item}")
+        __session__ = sessionmaker(self.engine)
+        with __session__() as session:
+            add_item = self.registry[table_name]()
+            for key in update_item.keys():
+                update_value = update_item[key]
+                setattr(add_item, key, update_value)
+            session.add(add_item)
+            session.commit()
+
+    def update_entry(self, table_name, current_id, update_item: dict) -> bool:
+        # self.log.info("update entry to table %s", table_name)
+        __session__ = sessionmaker(self.engine)
+        with __session__() as session:
+            existing_item = session.query(self.registry[table_name]).get(current_id)
+            changed = False
+            for key in update_item.keys():
+                update_value = update_item[key]
+                existing_value = getattr(existing_item, key)
+                if type(existing_value) is not type(update_value):
+                    existing_value = str(existing_value)
+                if existing_value != update_value:
+                    logging.info(f"{key} has changed: {existing_value} != {update_value}")
+                    setattr(existing_item, key, update_value)
+                    session.commit()
+                    changed = True
+                    logging.info(f"update {key} with {update_value}")
+        return changed
+
+    def add_link(self, link: str) -> dict:
+        result = {}
+        __session__ = sessionmaker(self.engine)
+        with __session__() as session:
+            media_file = MediaFile()
+            media_file.id = str(uuid.uuid4())
+            media_file.created_date = datetime.now()
+            media_file.last_modified_date = datetime.now()
+            media_file.version = 0
+            media_file.url = link
+            media_file.review = 1
+            media_file.should_download = 1
+            try:
+                session.add(media_file)
+                session.commit()
+                result['added'] = {'url': media_file.url, 'title': media_file.title, 'review': media_file.review, 'download': media_file.should_download}
+            except IntegrityError as error:
+                session.rollback()
+                result['error'] = error.orig
+        return result
+
+    def update_titles(self) -> dict:
+        update_list = {}
+        __session__ = sessionmaker(self.engine)
+        _filter = { 'review': True}
+        with __session__() as session:
+            links = session.query(MediaFile).filter_by(**_filter).all()
+            self.log.info("%d entries found for updating titles", len(links))
+            for link in links:
+                url = link.url
+                if url is None:
+                    continue
+                link.update_title()
+                session.commit()
+                update_list[link.id] = link.title
+        return update_list
+
+    def get_download_list(self) -> list[uuid.UUID]:
+        download_list = []
+        __session__ = sessionmaker(self.engine)
+        _filter = { 'should_download': True}
+        with __session__() as session:
+            links = session.query(MediaFile).filter_by(**_filter).all()
+            for link in links:
+                url = link.url
+                if url is None:
+                    continue
+                download_list.append(link.id)
+        return download_list
+
+    def download_file(self, entry_id: str, download_dir = "/data/media", dl_tool = "yt-dlp") -> str:
+        __session__ = sessionmaker(self.engine)
+        with __session__() as session:
+            link = session.query(MediaFile).get(entry_id)
+            link.download_file(download_dir, dl_tool)
+            session.commit()
+            file_name = link.file_name
+        return file_name
+
+    def delete_entries(self):
+        for (table_name, table) in self.registry.items():
+            # self.log.info("delete entries from table %s", table_name)
+            __session__ = sessionmaker(self.engine)
+            with __session__() as session:
+                items = session.query(table).all()
+                for item in items:
+                    session.delete(item)
+                session.commit()
+
+    def check_files(self):
+        pass

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

@@ -0,0 +1,101 @@
+import logging
+import re
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+import requests
+from bs4 import BeautifulSoup
+from sqlalchemy import Column, String, ForeignKey
+from sqlalchemy.dialects.mysql import BIT
+from sqlalchemy.orm import relationship
+
+from src.db.models.base import Base, BaseMixin, BaseVideoMixin
+
+
+class MediaFile(Base, BaseMixin, BaseVideoMixin):
+    __tablename__ = 'media_file'
+    media_actor_files = relationship("MediaActorFile")
+
+    def __repr__(self):
+        return f'MediaFile({self.id} {self.title} {self.title})'
+
+    def __str__(self):
+        return f'{self.title}({self.id})'
+
+    def update_title(self) -> None:
+        logging.info(f"update title for {self.url}")
+        try:
+            r = requests.get(self.url)
+            soup = BeautifulSoup(r.content, "html.parser")
+            title = soup.title.string
+            self.title = title
+            self.review = 0
+        except:
+            self.title = None
+            self.review = 1
+        self.last_modified_date = datetime.now()
+
+    def download_file(self, download_dir: str, dl_tool: str):
+        logging.info(f"download file for {self.url} to {download_dir}")
+        result = subprocess.run([dl_tool, self.url], cwd=download_dir, capture_output=True, text=True)
+        if result.returncode == 0:
+            output = result.stdout
+            output = re.sub(' +', ' ', output)
+            lines_list = output.splitlines()
+            file_name = self.__parse_output__(lines_list)
+            if file_name is None:
+                self.review = 1
+                self.should_download = 1
+                self.file_name = None
+            else:
+                download_file = Path(file_name)
+                self.should_download = 0
+                self.file_name = download_file.name
+                self.cloud_link = str(download_file.absolute())
+            self.last_modified_date = datetime.now()
+
+    def __parse_output__(self, lines_list):
+        self.file_name = None
+        for line in lines_list:
+            if 'has already been downloaded' in line:
+                end_len = len(' has already been downloaded')
+                self.file_name = line[11:-end_len]
+            if 'Destination' in line:
+                line_len = len(line)
+                start_len = len('[download] Destination: ')
+                file_len = line_len - start_len
+                self.file_name = line[-file_len:]
+        return self.file_name
+
+
+class MediaActor(Base, BaseMixin):
+    __tablename__ = 'media_actor'
+    name = Column(String(255))
+    media_actor_files = relationship("MediaActorFile")
+
+
+class MediaActorFile(Base, BaseMixin):
+    __tablename__ = 'media_actor_file'
+    media_actor_id = Column(String(255), ForeignKey("media_actor.id"), nullable=False)
+    media_actor = relationship("MediaActor", back_populates="media_actor_files")
+    media_file_id = Column(String(255), ForeignKey("media_file.id"), nullable=True)
+    media_file = relationship("MediaFile", back_populates="media_actor_files")
+
+
+class MediaArticle(Base, BaseMixin):
+    __tablename__ = 'media_article'
+    review = Column(BIT(1))
+    title = Column(String(255))
+    url = Column(String(255), unique=True)
+
+
+class MediaVideo(Base, BaseMixin):
+    __tablename__ = 'media_video'
+    cloud_link = Column(String(255))
+    file_name = Column(String(255))
+    path = Column(String(255))
+    review = Column(BIT(1))
+    title = Column(String(255))
+    url = Column(String(255), unique=True)
+    should_download = Column(BIT(1))

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

@@ -0,0 +1,42 @@
+from sqlalchemy import Column, String, ForeignKey, Integer
+from sqlalchemy.dialects.mysql import BIT
+from sqlalchemy.orm import relationship
+
+from src.db.models.base import Base, BaseMixin
+
+
+class MetaDataTable(Base, BaseMixin):
+    __tablename__ = 'meta_data_table'
+    table_name = Column(String(255), unique=True)
+    table_columns = relationship("MetaDataColumn")
+
+    def __repr__(self):
+        return f'MetaDataTable({self.id} {self.table_name})'
+
+    def __str__(self):
+        return f'{self.table_name}({self.id})'
+
+
+class MetaDataColumn(Base, BaseMixin):
+    __tablename__ = 'meta_data_column'
+    column_name = Column(String(255), nullable=False)
+    column_sync_name = Column(String(255))
+    column_type = Column(String(255))
+    column_modifier = Column(String(255), nullable=True)
+    column_order = Column(Integer)
+    table_id = Column(String, ForeignKey('meta_data_table.id'))
+    table = relationship("MetaDataTable", back_populates="table_columns")
+    column_label = Column(String(255))
+    filter_label = Column(String(255))
+    is_shown = Column(BIT(1))
+    show_filter = Column(BIT(1))
+    ref_column = Column(String, nullable=True)
+
+    def __repr__(self):
+        if self.column_name is None:
+            return f'MetaDataColumn({self.id} {self.table.table_name}.__)'
+        else:
+            return f'MetaDataColumn({self.id} {self.table.table_name}.{self.column_name})'
+
+    def __str__(self):
+        return f'{self.column_name}({self.id})'

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

@@ -0,0 +1,100 @@
+from sqlalchemy import Column, Integer, String, ForeignKey, UniqueConstraint
+from sqlalchemy.dialects.mysql import BIT
+from sqlalchemy.orm import relationship
+
+from src.db.models.base import Base, BaseMixin
+
+
+class Sport(Base, BaseMixin):
+    __tablename__ = "sport"
+    __table_args__ = (
+        UniqueConstraint("name"),
+    )
+    name = Column(String(255), nullable=False, index=True, unique=True)
+    teams = relationship("Team")
+    positions = relationship("FieldPosition")
+
+
+class Team(Base, BaseMixin):
+    __tablename__ = "team"
+    name = Column(String(255), nullable=False, index=True, unique=True)
+    short_name = Column(String(255), nullable=False, )
+    sport_id = Column(String, ForeignKey("sport.id"), nullable=False)
+    sport = relationship("Sport", back_populates="teams")
+    roosters = relationship("Rooster")
+
+
+class FieldPosition(Base, BaseMixin):
+    __tablename__ = "field_position"
+    __table_args__ = (
+        UniqueConstraint("name", "sport_id"),
+        UniqueConstraint("short_name", "sport_id"),
+    )
+    name = Column(String(255), nullable=False, index=True)
+    short_name = Column(String(255), nullable=False)
+    sport_id = Column(String, ForeignKey("sport.id"), nullable=False, index=True)
+    sport = relationship("Sport", back_populates="positions")
+    roosters = relationship("Rooster")
+
+
+class Player(Base, BaseMixin):
+    __tablename__ = "player"
+    __table_args__ = (
+        UniqueConstraint("first_name", "last_name"),
+    )
+    first_name = Column(String(255), nullable=False, index=True)
+    last_name = Column(String(255), nullable=False, index=True)
+    roosters = relationship("Rooster")
+
+    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 = Column(Integer)
+    team_id = Column(String, ForeignKey("team.id"), nullable=False, index=True)
+    team = relationship("Team", back_populates="roosters")
+    player_id = Column(String, ForeignKey("player.id"), nullable=False, index=True)
+    player = relationship("Player", back_populates="roosters")
+    position_id = Column(String, ForeignKey("field_position.id"), nullable=False, index=True)
+    position = relationship("FieldPosition", back_populates="roosters")
+    cards = relationship("Card")
+
+
+class Vendor(Base, BaseMixin):
+    __tablename__ = "vendor"
+    name = Column(String(255), nullable=False, unique=True, index=True)
+    card_sets = relationship("CardSet")
+    cards = relationship("Card")
+
+
+class CardSet(Base, BaseMixin):
+    __tablename__ = "card_set"
+    __table_args__ = (
+        UniqueConstraint("name", "vendor_id"),
+    )
+    name = Column(String(255), index=True)
+    parallel_set = Column(BIT(1))
+    insert_set = Column(BIT(1))
+    vendor_id = Column(String, ForeignKey("vendor.id"), nullable=False, index=True)
+    vendor = relationship("Vendor", back_populates="card_sets")
+    cards = relationship("Card")
+
+
+class Card(Base, BaseMixin):
+    __tablename__ = "card"
+    __table_args__ = (
+        UniqueConstraint("card_number", "year", "vendor_id", "card_set_id"),
+    )
+    card_number = Column(Integer, index=True)
+    year = Column(Integer, index=True)
+    card_set_id = Column(String, ForeignKey("card_set.id"), nullable=False)
+    card_set = relationship("CardSet", back_populates="cards")
+    rooster_id = Column(String, ForeignKey("rooster.id"), nullable=False)
+    rooster = relationship("Rooster", back_populates="cards")
+    vendor_id = Column(String, ForeignKey("vendor.id"), nullable=False)
+    vendor = relationship("Vendor", back_populates="cards")

kontor-api/src/db/session.py

@@ -0,0 +1,15 @@
+from typing import Generator, Annotated
+
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, Session
+
+from src.core.config import settings
+
+SQLALCHEMY_DATABASE_URL = settings.DATABASE_URL
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+
+SessionLocal = sessionmaker(bind=engine)
+
+def get_db() -> Generator:
+    with SessionLocal() as db:
+        yield db

kontor-api/src/main.py

@@ -0,0 +1,29 @@
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+
+from src.apis.base import api_router
+from src.db.session import engine
+from src.webapps.base import api_router as web_app_router
+from src.core.config import settings
+from src.db.models.base import Base
+
+def include_router(app: FastAPI):
+    app.include_router(api_router)
+    app.include_router(web_app_router)
+
+def configure_static(app: FastAPI):
+    app.mount("/static", StaticFiles(directory="src/static"), name="static")
+
+def create_tables():
+    Base.metadata.create_all(bind=engine)
+
+def start_application():
+    app = FastAPI(title=settings.PROJECT_NAME, version=settings.PROJECT_VERSION)
+    include_router(app)
+    configure_static(app)
+    create_tables()
+    return app
+
+
+kontor = start_application()
+

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

@@ -0,0 +1,36 @@
+from typing import List, Dict
+from uuid import UUID
+
+from pydantic import BaseModel
+
+from src.db.models.comic import Artist
+
+
+class ArtistCreation(BaseModel):
+    name: str
+
+class ArtistResponse(BaseModel):
+    id: UUID
+    name: str
+
+class ArtistDetailResponse(BaseModel):
+    id: UUID
+    name: str
+    works: Dict[str, List[str]]
+
+def get_artist_details(artist: Artist) -> ArtistDetailResponse:
+    works = {}
+    for work in artist.comic_works:
+        work_type = work.work_type.name
+        comic_title = work.comic.title
+        if work_type in works:
+            works[work_type].append(comic_title)
+        else:
+            works[work_type] = [comic_title]
+    response = ArtistDetailResponse(
+        id=artist.id,
+        name=artist.name,
+        works=works
+    )
+    return response
+

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

@@ -0,0 +1,56 @@
+from typing import List, Dict
+from uuid import UUID
+
+from pydantic import BaseModel
+
+from src.db.models.comic import Comic
+
+
+class ComicResponse(BaseModel):
+    id: UUID
+    title: str
+    completed: bool
+
+class ComicDetailsResponse(BaseModel):
+    id: UUID
+    created: str
+    title: str
+    completed : bool
+    current_order : bool
+    publisher: str
+    volumes: List[str]
+    works: Dict[str, List[str]]
+
+def get_short_info(comic: Comic) -> ComicResponse:
+    response = ComicResponse(
+        id=comic.id,
+        title=comic.title,
+        completed=(comic.completed == 1)
+    )
+    return response
+
+
+def get_comic_details(comic: Comic) -> ComicDetailsResponse | None:
+    volumes = []
+    for volume in comic.volumes:
+        volumes.append(volume.name)
+    works = {}
+    for work in comic.comic_works:
+        work_type = work.work_type.name
+        artist_name = work.artist.name
+        if work_type in works:
+            works[work_type].append(artist_name)
+        else:
+            works[work_type] = [artist_name]
+    response = ComicDetailsResponse(
+        id=comic.id,
+        created=str(comic.created_date),
+        title=comic.title,
+        completed=(comic.completed == 1),
+        current_order=(comic.current_order == 1),
+        publisher=comic.publisher.name,
+        volumes=volumes,
+        works=works
+    )
+    return response
+

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

@@ -0,0 +1,45 @@
+from datetime import datetime
+from uuid import UUID
+
+from src.db.models.media import MediaFile
+from pydantic import BaseModel
+
+
+class MediaFileResponse(BaseModel):
+    id: UUID
+    title: str | None = None
+    file_name: str | None = None
+    cloud_link: str | None = None
+    url: str
+    review: bool = False
+    should_download: bool = False
+
+class Link(BaseModel):
+    url: str
+
+def get_file_details(mediafile: MediaFile) -> MediaFileResponse | None:
+    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 == 1),
+                                 should_download=(mediafile.should_download == 1))
+    #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
+    mediafile.url = model.url
+    mediafile.title = model.title
+    mediafile.last_modified_date = datetime.now()
+    if model.review:
+        mediafile.review = 1
+    else:
+        mediafile.review = 0
+    if model.should_download:
+        mediafile.should_download = 1
+    else:
+        mediafile.should_download = 0

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

@@ -0,0 +1,8 @@
+from uuid import UUID
+
+from pydantic import BaseModel
+
+
+class SportResponse(BaseModel):
+    id: UUID
+    name: str

kontor-api/src/static/js/autocomplete.js

@@ -0,0 +1,5 @@
+$( function() {
+    $( "#autocomplete" ).autocomplete({
+      source: "/jobs/autocomplete"
+    });
+  } );

kontor-api/src/templates/comic/artist_detail.html

@@ -0,0 +1,50 @@
+{% extends "shared/base.html" %}
+
+
+{% block title %}
+  <title>Artist Detail</title>
+{% endblock %}
+
+{% block content %}
+  <div class="container">
+  <div class="row">
+    <div class="col">
+      <h1 class="display-5">Artist Detail</h1>
+    </div>
+  </div>
+
+  <div class="row">
+      <table class="table table-striped table-hover">
+        <tbody>
+          <tr>
+            <th scope="row">Artist Name</th>
+            <td colspan="2">{{artist.name}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Works</th>
+            <td colspan="2">
+                {% for work in artist.get_comics() %}
+                    <p>
+                        {{work}}:
+                        <ul>
+                          {% for comic in artist.get_comics()[work] %}
+                            <li><a href="/comic/comics/{{comic.id}}">{{comic.title}}</a></li>
+                          {% endfor %}
+                        </ul>
+                    </p>
+                {% endfor %}
+            </td>
+          </tr>
+          <tr>
+            <th scope="row">Data Created</th>
+            <td colspan="2">{{artist.created_date}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Data Modified</th>
+            <td colspan="2">{{artist.last_modified_date}}</td>
+          </tr>
+        </tbody>
+    </table>
+  </div>
+</div>
+{% endblock %}

kontor-api/src/templates/comic/artists.html

@@ -0,0 +1,32 @@
+{% extends "shared/base.html" %}
+
+{% block title %}
+  <title>Comic Artists</title>
+{% endblock %}
+
+{% block content %}
+  {% with msg=msg %}
+    {% include "components/alerts.html" %}
+  {% endwith %}
+  <div class="container">
+  <div class="row">
+    <div class="col">
+      <h1 class="display-5">Find Artists..</h1>
+    </div>
+  </div>
+  <div class="row">
+      {% for artist in artists %}
+        <div class="col-lg-4 col-md-3 col-sm-10 mr-auto">
+          {% with obj=artist %}
+      		{% include "components/artist_cards.html" %}
+    	    {% endwith %}
+
+          {% if loop.index %3 %}
+            </div>
+          {% else %}
+            </div></div><br><div class="row">
+          {% endif %}
+      {% endfor %}
+  </div>
+</div>
+{% endblock %}

kontor-api/src/templates/comic/comic_detail.html

@@ -0,0 +1,71 @@
+{% extends "shared/base.html" %}
+
+
+{% block title %}
+  <title>Comic Detail</title>
+{% endblock %}
+
+{% block content %}
+<div class="container">
+
+  <div class="row">
+      <table class="table table-striped table-hover">
+        <tbody>
+          <tr>
+            <th scope="row">Comic Title</th>
+            <td colspan="2">{{comic.title}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Publisher</th>
+            <td colspan="2"><a href="/comic/publishers/{{comic.publisher.id}}">{{comic.publisher.name}}</a></td>
+          </tr>
+          <tr>
+            <th scope="row">Completed</th>
+            <td colspan="2">
+              {% with check=comic.completed %}
+      		    {% include "components/check.html" %}
+    	      {% endwith %}
+            </td>
+          </tr>
+          <tr>
+            <th scope="row">Works</th>
+            <td colspan="2">
+              {% for work in comic.get_artists() %}
+                    <p>
+                        {{work}}:
+                        <ul>
+                          {% for artist in comic.get_artists()[work] %}
+                            <li><a href="/comic/artists/{{artist.id}}">{{artist.name}}</a></li>
+                          {% endfor %}
+                        </ul>
+                    </p>
+                {% endfor %}
+              </td>
+          </tr>
+          <tr>
+            <th scope="row">Data Created</th>
+            <td colspan="2">{{comic.created_date}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Data Modified</th>
+            <td colspan="2">{{comic.last_modified_date}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Data Version</th>
+            <td colspan="2">{{comic.version}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Issues</th>
+            <td colspan="2">
+              <ul>
+                {% for issue in comic.sorted_issues() %}
+                  <li><a href="comic/issues/{{issue.id}}">{{issue.issue_number}}</a></li>
+                {% endfor %}
+              </ul>
+            </td>
+          </tr>
+        </tbody>
+    </table>
+  </div>
+</div>
+{% endblock %}

kontor-api/src/templates/comic/comics.html

@@ -0,0 +1,31 @@
+{% extends "shared/base.html" %}
+
+{% block title %}
+  <title>Comic List</title>
+{% endblock %}
+
+{% block content %}
+  {% with msg=msg %}
+    {% include "components/alerts.html" %}
+  {% endwith %}
+  <div class="container">
+  <div class="row">
+    <div class="col">
+      <h1 class="display-5">Find Jobs..</h1>
+    </div>
+  </div>
+  <div class="row">
+      {% for comic in comics %}
+        <div class="col-lg-4 col-md-3 col-sm-10 mr-auto">
+          {% with obj=comic %}
+      		{% include "components/comic_cards.html" %}
+    	  {% endwith %}
+          {% if loop.index %3 %}
+            </div>
+          {% else %}
+            </div></div><br><div class="row">
+          {% endif %}
+      {% endfor %}
+  </div>
+</div>
+{% endblock %}

kontor-api/src/templates/comic/publisher_detail.html

@@ -0,0 +1,45 @@
+{% extends "shared/base.html" %}
+
+
+{% block title %}
+  <title>Publisher Detail</title>
+{% endblock %}
+
+{% block content %}
+  <div class="container">
+  <div class="row">
+    <div class="col">
+      <h1 class="display-5">Publisher Detail</h1>
+    </div>
+  </div>
+
+  <div class="row">
+      <table class="table table-striped table-hover">
+        <tbody>
+          <tr>
+            <th scope="row">Publisher Name</th>
+            <td colspan="2">{{publisher.name}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Comics</th>
+            <td colspan="2">
+              <ul>
+                {% for comic in publisher.comics %}
+                    <li><a href="/comic/comics/{{comic.id}}">{{comic.title}}</a></li>
+                {% endfor %}
+              </ul>
+            </td>
+          </tr>
+          <tr>
+            <th scope="row">Data Created</th>
+            <td colspan="2">{{publisher.created_date}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Data Modified</th>
+            <td colspan="2">{{publisher.last_modified_date}}</td>
+          </tr>
+        </tbody>
+    </table>
+  </div>
+</div>
+{% endblock %}

kontor-api/src/templates/comic/publishers.html

@@ -0,0 +1,31 @@
+{% extends "shared/base.html" %}
+
+{% block title %}
+  <title>Publisher List</title>
+{% endblock %}
+
+{% block content %}
+  {% with msg=msg %}
+    {% include "components/alerts.html" %}
+  {% endwith %}
+  <div class="container">
+  <div class="row">
+    <div class="col">
+      <h1 class="display-5">Find Publishers..</h1>
+    </div>
+  </div>
+  <div class="row">
+      {% for publisher in publishers %}
+        <div class="col-lg-4 col-md-3 col-sm-10 mr-auto">
+          {% with obj=publisher %}
+      		{% include "components/publisher_cards.html" %}
+    	  {% endwith %}
+          {% if loop.index %3 %}
+            </div>
+          {% else %}
+            </div></div><br><div class="row">
+          {% endif %}
+      {% endfor %}
+  </div>
+</div>
+{% endblock %}

kontor-api/src/templates/components/actor_cards.html

@@ -0,0 +1,6 @@
+<div class="card shadow p-3 mb-2 bg-body rounded" style="width: 18rem;">
+  <div class="card-body">
+    <h5 class="card-title">{{obj.name}}</h5>
+    <a href="/media/actors/{{obj.id}}" class="btn btn-primary">Read more</a>
+  </div>
+</div>

kontor-api/src/templates/components/alerts.html

@@ -0,0 +1,5 @@
+{% if msg %}
+  <div class="alert alert-info" role="alert">
+    {{msg}}
+  </div>
+{% endif %}

kontor-api/src/templates/components/artist_cards.html

@@ -0,0 +1,6 @@
+<div class="card shadow p-3 mb-2 bg-body rounded" style="width: 18rem;">
+  <div class="card-body">
+    <h5 class="card-title">{{obj.name}}</h5>
+    <a href="/comic/artists/{{obj.id}}" class="btn btn-primary">Read more</a>
+  </div>
+</div>

kontor-api/src/templates/components/check.html

@@ -0,0 +1,5 @@
+{% if check == 1 %}
+    <img src="{{ url_for('static', path='images/tick.png') }}" alt="" width="24" height="24">
+{% else %}
+    <img src="{{ url_for('static', path='images/cross.png') }}" alt="" width="24" height="24">
+{% endif %}

kontor-api/src/templates/components/comic_cards.html

@@ -0,0 +1,8 @@
+<div class="card shadow p-3 mb-2 bg-body rounded" style="width: 18rem;">
+  <div class="card-body">
+    <h5 class="card-title">{{obj.title}}</h5>
+    <p class="card-text">Publisher : {{obj.publisher.name}}</p>
+    <p class="card-text">Completed : {% with check=obj.completed %}{% include "components/check.html" %}{% endwith %}</p>
+    <a href="/comic/comics/{{obj.id}}" class="btn btn-primary">Read more</a>
+  </div>
+</div>

kontor-api/src/templates/components/navbar.html

@@ -0,0 +1,66 @@
+<nav class="navbar navbar-expand-lg navbar-light bg-light px-5">
+  <div class="container-fluid">
+    <a class="navbar-brand" href="#">
+      <img src="{{ url_for('static', path='images/logo.png') }}" alt="" width="30" height="24">
+    </a>
+    <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#navbarSupportedContent" aria-controls="navbarSupportedContent" aria-expanded="false" aria-label="Toggle navigation">
+      <span class="navbar-toggler-icon"></span>
+    </button>
+    <div class="collapse navbar-collapse" id="navbarSupportedContent">
+      <ul class="navbar-nav me-auto mb-2 mb-lg-0">
+        <li class="nav-item">
+          <a class="nav-link active" aria-current="page" href="/">Home</a>
+        </li>
+        <li class="nav-item dropdown">
+          <a class="nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-bs-toggle="dropdown" aria-expanded="false">Comics</a>
+          <ul class="dropdown-menu" aria-labelledby="navbarDropdown">
+            <li><a class="dropdown-item" href="/comic/comics/">Comics</a></li>
+            <li><a class="dropdown-item" href="/comic/artists/">Artists</a></li>
+            <li><a class="dropdown-item" href="/comic/publishers/">Publishers</a></li>
+            <li><hr class="dropdown-divider"></li>
+            <li><a class="dropdown-item" href="#">Something else here</a></li>
+          </ul>
+        </li>
+        <li class="nav-item dropdown">
+          <a class="nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-bs-toggle="dropdown" aria-expanded="false">Media</a>
+          <ul class="dropdown-menu" aria-labelledby="navbarDropdown">
+            <li><a class="dropdown-item" href="/media/files/">MediaFiles</a></li>
+            <li><a class="dropdown-item" href="/media/actors/">MediaActors</a></li>
+          </ul>
+        </li>
+        <li class="nav-item">
+          <a class="nav-link" href="/docs/">Docs</a>
+        </li>
+        <li class="nav-item">
+          <a class="nav-link" href="/redoc/">Redoc</a>
+        </li>
+        <li class="nav-item dropdown">
+          <a class="nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-bs-toggle="dropdown" aria-expanded="false">
+            Account
+          </a>
+          <ul class="dropdown-menu" aria-labelledby="navbarDropdown">
+            <li><a class="dropdown-item" href="/register/">Signup</a></li>
+            <li><a class="dropdown-item" href="/login/">Login</a></li>
+            <li><hr class="dropdown-divider"></li>
+            <li><a class="dropdown-item" href="#">Something else here</a></li>
+          </ul>
+        </li>
+      </ul>
+      <ul class="navbar-nav ml-auto mb-2 mb-lg-0">
+        <li class="nav-item dropdown">
+          <a class="nav-link dropdown-toggle" href="#" id="navbarDropdown" role="button" data-bs-toggle="dropdown" aria-expanded="false">
+            Jobs
+          </a>
+          <ul class="dropdown-menu" aria-labelledby="navbarDropdown">
+            <li><a class="dropdown-item" href="/comics/">Comics</a></li>
+            <li><a class="dropdown-item" href="/comics/">Media</a></li>
+          </ul>
+        </li>
+      </ul>
+      <form class="d-flex" action="/search/">
+        <input class="form-control me-2" name="query" id="autocomplete" type="search" placeholder="Search" aria-label="Search">
+        <button class="btn btn-outline-success" type="submit">Search</button>
+      </form>
+    </div>
+  </div>
+</nav>

kontor-api/src/templates/components/publisher_cards.html

@@ -0,0 +1,6 @@
+<div class="card shadow p-3 mb-2 bg-body rounded" style="width: 18rem;">
+  <div class="card-body">
+    <h5 class="card-title">{{obj.name}}</h5>
+    <a href="/comic/publishers/{{obj.id}}" class="btn btn-primary">Read more</a>
+  </div>
+</div>

kontor-api/src/templates/index.html

@@ -0,0 +1,14 @@
+{% extends "shared/base.html" %}
+
+
+{% block title %}
+  <title>Kontor</title>
+{% endblock %}
+
+{% block content %}
+  {% with msg=msg %}
+    {% include "components/alerts.html" %}
+  {% endwith %}
+  <div class="container">
+  </div>
+{% endblock %}

kontor-api/src/templates/media/actor_detail.html

@@ -0,0 +1,45 @@
+{% extends "shared/base.html" %}
+
+
+{% block title %}
+  <title>Actor Detail</title>
+{% endblock %}
+
+{% block content %}
+  <div class="container">
+  <div class="row">
+    <div class="col">
+      <h1 class="display-5">Actor Detail</h1>
+    </div>
+  </div>
+
+  <div class="row">
+      <table class="table table-striped table-hover">
+        <tbody>
+          <tr>
+            <th scope="row">Actor Name</th>
+            <td colspan="2">{{actor.name}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Works</th>
+            <td colspan="2">
+                <ul>
+                {% for media_actor_files in actor.media_actor_files %}
+                    <li><a href="/media/files/{{media_actor_files.media_file.id}}">{{media_actor_files.media_file.title}}</a></li>
+                {% endfor %}
+                </ul>
+            </td>
+          </tr>
+          <tr>
+            <th scope="row">Data Created</th>
+            <td colspan="2">{{actor.created_date}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Data Modified</th>
+            <td colspan="2">{{actor.last_modified_date}}</td>
+          </tr>
+        </tbody>
+    </table>
+  </div>
+</div>
+{% endblock %}

kontor-api/src/templates/media/actors.html

@@ -0,0 +1,32 @@
+{% extends "shared/base.html" %}
+
+{% block title %}
+  <title>MediaFile Actors</title>
+{% endblock %}
+
+{% block content %}
+  {% with msg=msg %}
+    {% include "components/alerts.html" %}
+  {% endwith %}
+  <div class="container">
+  <div class="row">
+    <div class="col">
+      <h1 class="display-5">Actors..</h1>
+    </div>
+  </div>
+  <div class="row">
+      {% for actor in actors %}
+        <div class="col-lg-4 col-md-3 col-sm-10 mr-auto">
+          {% with obj=actor %}
+      		{% include "components/actor_cards.html" %}
+    	  {% endwith %}
+
+          {% if loop.index %3 %}
+            </div>
+          {% else %}
+            </div></div><br><div class="row">
+          {% endif %}
+      {% endfor %}
+  </div>
+</div>
+{% endblock %}

kontor-api/src/templates/media/file_detail.html

@@ -0,0 +1,65 @@
+{% extends "shared/base.html" %}
+
+
+{% block title %}
+  <title>MediaFile Detail</title>
+{% endblock %}
+
+{% block content %}
+  <div class="container">
+  <div class="row">
+    <div class="col">
+      <h1 class="display-5">MediaFile Detail</h1>
+    </div>
+  </div>
+
+  <div class="row">
+      <table class="table table-striped table-hover">
+        <tbody>
+          <tr>
+            <th scope="row">MediaFile Title</th>
+            <td colspan="2">{{mediafile.title}}</td>
+          </tr>
+          <tr>
+            <th scope="row">MediaFile URL</th>
+            <td colspan="2">{{mediafile.url}}</td>
+          </tr>
+          <tr>
+            <th scope="row">MediaFile Cloudlink</th>
+            <td colspan="2">{{mediafile.cloud_link}}</td>
+          </tr>
+          <tr>
+            <th scope="row">MediaFile Download?</th>
+            <td colspan="2">{{mediafile.should_download}}</td>
+          </tr>
+          <tr>
+            <th scope="row">MediaFile Review?</th>
+            <td colspan="2">{{mediafile.review}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Actors</th>
+            <td colspan="2">
+                <ul>
+                {% for media_actor_files in mediafile.media_actor_files %}
+                    <li><a href="/media/actors/{{media_actor_files.media_actor.id}}">{{media_actor_files.media_actor.name}}</a></li>
+                {% endfor %}
+                </ul>
+            </td>
+          </tr>
+          <tr>
+            <th scope="row">Data Created</th>
+            <td colspan="2">{{mediafile.created_date}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Data Modified</th>
+            <td colspan="2">{{mediafile.last_modified_date}}</td>
+          </tr>
+          <tr>
+            <th scope="row">Data Version</th>
+            <td colspan="2">{{mediafile.version}}</td>
+          </tr>
+        </tbody>
+    </table>
+  </div>
+</div>
+{% endblock %}

kontor-api/src/templates/media/files.html

@@ -0,0 +1,29 @@
+{% extends "shared/base.html" %}
+
+{% block title %}
+  <title>MediaFiles List</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">URL</th>
+        <th scope="col">Cloudlink</th>
+      </tr></thead>
+      <tbody>
+          {%  for mediafile in mediafiles %}
+         <tr>
+           <th scope="row"><a href="/media/files/{{mediafile.id}}">{{mediafile.title}}</a></th>
+           <td>{{mediafile.url}}</td>
+           <td>{{mediafile.cloud_link}}</td>
+         </tr>
+          {% endfor %}
+      </tbody>
+    </table>
+  </div>
+{% endblock %}

kontor-api/src/templates/shared/base.html

@@ -0,0 +1,26 @@
+<!DOCTYPE html>
+<html lang="en-us">
+<head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-BmbxuPwQa2lc/FVzBcNJ7UAyJxM6wuqIj61tLrc4wSX0szH/Ev+nYRRuWlolflfl" crossorigin="anonymous">
+    <link rel="stylesheet" href="//code.jquery.com/ui/1.12.1/themes/base/jquery-ui.css">
+    {% block title %}
+    {% endblock %}
+</head>
+
+<body>
+    {% include "components/navbar.html" %}
+    {% block content %}
+    {% endblock %}
+
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta2/dist/js/bootstrap.bundle.min.js" integrity="sha384-b5kHyXgcpbZJO/tY9Ul7kGkf1S0CWuKcCD38l8YkeH8z8QjE0GmW1gYU5S9FOnJ0" crossorigin="anonymous"></script>
+    <script src="https://code.jquery.com/jquery-3.6.0.min.js" integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=" crossorigin="anonymous"></script>
+    <script src="https://code.jquery.com/ui/1.12.1/jquery-ui.js"></script>
+    <script src="{{ url_for('static', path='js/autocomplete.js') }}"></script>
+    {% block scripts %}
+    {% endblock %}
+
+
+</body>
+</html>

kontor-api/src/webapps/base.py

@@ -0,0 +1,15 @@
+from fastapi import APIRouter, Request
+from fastapi.templating import Jinja2Templates
+
+from src.webapps.comic import route_comics
+from src.webapps.media import route_media
+
+templates = Jinja2Templates(directory="src/templates")
+
+api_router = APIRouter()
+api_router.include_router(route_comics.router)
+api_router.include_router(route_media.router)
+
+@api_router.get("/")
+def home(request: Request, msg: str = None):
+    return templates.TemplateResponse("index.html", {"request": request, "msg": msg})

kontor-api/src/webapps/comic/route_comics.py

@@ -0,0 +1,42 @@
+from uuid import UUID
+
+from fastapi import APIRouter, Request
+from fastapi.templating import Jinja2Templates
+
+from src.apis.utils import SessionDep
+from src.db.models.comic import Comic, Artist, Publisher
+
+templates = Jinja2Templates(directory="src/templates")
+router = APIRouter(include_in_schema=False, prefix="/comic")
+
+@router.get("/comics")
+def get_comics(db: SessionDep, request: Request, msg: str = None):
+    comics = db.query(Comic).all()
+    return templates.TemplateResponse("comic/comics.html", {"request": request, "msg": msg, "comics": comics})
+
+@router.get("/comics/{comic_id}")
+def comic_details(comic_id: UUID, request: Request, db: SessionDep):
+    comic = db.get(Comic, comic_id)
+    return templates.TemplateResponse("comic/comic_detail.html", {"request": request, "comic":comic})
+
+@router.get("/artists")
+def get_artists(db: SessionDep, request: Request, msg: str = None):
+    artists = db.query(Artist).all()
+    return templates.TemplateResponse("comic/artists.html", {"request": request, "msg": msg, "artists": artists})
+
+@router.get("/artists/{artist_id}")
+def artist_detail(artist_id: UUID, request: Request, db: SessionDep):
+    artist = db.get(Artist, artist_id)
+    return templates.TemplateResponse("comic/artist_detail.html", {"request": request, "artist": artist})
+
+@router.get("/publishers")
+def get_publishers(db: SessionDep, request: Request, msg: str = None):
+    publishers = db.query(Publisher).all()
+    return templates.TemplateResponse("comic/publishers.html", {"request": request, "publishers": publishers})
+
+@router.get("/publishers/{publisher_id}")
+def publisher_details(publisher_id: UUID, request: Request, db: SessionDep, msg: str = None):
+    publisher = db.get(Publisher, publisher_id)
+    if publisher is None:
+        msg = "Could not find Publisher"
+    return templates.TemplateResponse("comic/publisher_detail.html", {"request": request, "msg": msg, "publisher": publisher})

kontor-api/src/webapps/media/route_media.py

@@ -0,0 +1,32 @@
+from uuid import UUID
+
+from fastapi import APIRouter, Request
+from fastapi.templating import Jinja2Templates
+
+from src.apis.utils import SessionDep
+from src.db.models.media import MediaFile, MediaActor
+#ifrom src.schema.media.comic import get_comic_details
+
+templates = Jinja2Templates(directory="src/templates")
+router = APIRouter(include_in_schema=False, prefix="/media")
+
+@router.get("/files")
+def get_mediafiles(db: SessionDep, request: Request, msg: str = None):
+    mediafiles = db.query(MediaFile).all()
+    return templates.TemplateResponse("media/files.html", {"request": request, "msg": msg, "mediafiles": mediafiles})
+
+@router.get("/files/{file_id}")
+def file_details(file_id: UUID, request: Request, db: SessionDep):
+    mediafile = db.get(MediaFile, file_id)
+    return templates.TemplateResponse("media/file_detail.html", {"request": request, "mediafile":mediafile})
+
+@router.get("/actors")
+def get_actors(db: SessionDep, request: Request, msg: str = None):
+    actors = db.query(MediaActor).all()
+    return templates.TemplateResponse("media/actors.html", {"request": request, "msg": msg, "actors": actors})
+
+@router.get("/actors/{actor_id}")
+def artist_detail(actor_id: UUID, request: Request, db: SessionDep):
+    actor = db.get(MediaActor, actor_id)
+    return templates.TemplateResponse("media/actor_detail.html", {"request": request, "actor": actor})
+