add publishing of kontor-model

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

.gitignore

@@ -11,3 +11,4 @@ kontor-robyn.bak
 kontor-robyn.bak2
 kontor-data/.gradle
 kontor-data/build/
+/kontor-api/kontor-api.code-workspace

deploy-kontor.sh

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

integration/.gitattributes

@@ -1,3 +0,0 @@
-/gradlew text eol=lf
-*.bat text eol=crlf
-*.jar binary

integration/.gitignore

@@ -1,37 +0,0 @@
-HELP.md
-.gradle
-build/
-!gradle/wrapper/gradle-wrapper.jar
-!**/src/main/**/build/
-!**/src/test/**/build/
-
-### STS ###
-.apt_generated
-.classpath
-.factorypath
-.project
-.settings
-.springBeans
-.sts4-cache
-bin/
-!**/src/main/**/bin/
-!**/src/test/**/bin/
-
-### IntelliJ IDEA ###
-.idea
-*.iws
-*.iml
-*.ipr
-out/
-!**/src/main/**/out/
-!**/src/test/**/out/
-
-### NetBeans ###
-/nbproject/private/
-/nbbuild/
-/dist/
-/nbdist/
-/.nb-gradle/
-
-### VS Code ###
-.vscode/

integration/build.gradle

@@ -1,51 +0,0 @@
-plugins {
-	id 'java'
-	id 'org.springframework.boot' version '4.0.7'
-	id 'io.spring.dependency-management' version '1.1.7'
-    alias(libs.plugins.lombok)
-}
-
-group = 'de.thpeetz.kontor'
-version = '0.3.0-SNAPSHOT'
-
-java {
-	toolchain {
-		languageVersion = JavaLanguageVersion.of(21)
-	}
-}
-
-repositories {
-	mavenCentral()
-    maven { setUrl("https://repo.spring.io/milestone") }
-}
-
-dependencyManagement {
-    imports {
-        mavenBom libs.camel.bom.get().toString()
-    }
-}
-
-dependencies {
-	implementation 'org.springframework.boot:spring-boot-starter-actuator'
-	implementation 'org.springframework.boot:spring-boot-starter-artemis'
-	implementation 'org.springframework.boot:spring-boot-starter-webmvc'
-    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
-	implementation 'org.apache.camel.springboot:camel-spring-boot-starter:4.20.0'
-    implementation 'org.apache.camel.springboot:camel-jms-starter'
-    implementation 'io.micrometer:micrometer-registry-prometheus'
-    implementation 'org.apache.activemq:artemis-jakarta-client'
-    implementation 'org.postgresql:postgresql'
-    implementation libs.jackson
-    implementation libs.gson
-	runtimeOnly 'io.micrometer:micrometer-registry-prometheus'
-    compileOnly 'org.projectlombok:lombok'
-    annotationProcessor 'org.projectlombok:lombok'
-    testImplementation 'org.apache.camel:camel-test-spring-junit5'
-	testImplementation 'org.springframework.boot:spring-boot-starter-artemis-test'
-	testImplementation 'org.springframework.boot:spring-boot-starter-webmvc-test'
-	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
-}
-
-tasks.named('test') {
-	useJUnitPlatform()
-}

integration/gradle/libs.versions.toml

@@ -1,72 +0,0 @@
-[versions]
-gradle = "8.6"
-args4j = "2.33"
-commonscli = "1.5.0"
-junit = "5.8.2"
-logback = "1.1.2"
-mockito = "1.9.5"
-picoli = "4.7.0"
-slf4j = "1.7.22"
-hsqldb = "2.7.1"
-sqlite = "3.25.2"
-spotbugs = "6.0.7"
-asciidoctor = "4.0.2"
-rouge = "3.15.0"
-#diagram = "2.2.2"
-diagram = "2.3.1"
-sonarqube = "3.3"
-cimtConventions = "1.0.0-SNAPSHOT"
-springboot = "3.2.5"
-springdependencies = "1.1.4"
-vaadin = "24.3.8"
-camel = "4.10.6"
-artemis = "2.41.0"
-lombok = "8.6"
-gson = "2.9.0"
-jackson = "2.16.1"
-json_simple = "1.1.1"
-mail = "1.6.2"
-hypersistence = "3.9.10"
-
-[libraries]
-args4j = { module = "args4j:args4j", version.ref = "args4j" }
-commonscli = { module = "commons-cli:commons-cli", version.ref = "commonscli" }
-junit = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit" }
-logbackCore = { module = "ch.qos.logback:logback-core", version.ref = "logback" }
-logbackClassic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
-mockito = { module = "org.mockito:mockito-all", version.ref = "mockito" }
-picocli = { module = "info.picocli:picocli", version.ref = "picoli" }
-slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
-hsqldb = { module = "org.hsqldb:hsqldb", version.ref = "hsqldb" }
-gson = { module = "com.google.code.gson:gson", version.ref = "gson" }
-jackson = { module = "com.fasterxml.jackson.core:jackson-databind", version.ref = "jackson" }
-json = { module = "com.googlecode.json-simple:json-simple", version.ref ="json_simple" }
-mail = { module = "com.sun.mail:javax.mail", version.ref  ="mail" }
-sqlite-jdbc = { module = "org.xerial:sqlite-jdbc", version.ref = "sqlite" }
-hypersistence = { module = "io.hypersistence:hypersistence-utils-hibernate-63", version.ref = "hypersistence" }
-vaadin-bom = { module = "com.vaadin:vaadin-bom", version.ref = "vaadin" }
-camel-bom = { module = "org.apache.camel.springboot:camel-spring-boot-bom", version.ref = "camel"}
-artemis = { module = "org.apache.activemq:artemis-jms-server", version.ref = "artemis" }
-asciidoctorGradleJvmGems = { module = "org.asciidoctor:asciidoctor-gradle-jvm-gems", version.ref= "asciidoctor" }
-asciidoctorGradleJvm = { module = "org.asciidoctor:asciidoctor-gradle-jvm", version.ref= "asciidoctor" }
-asciidoctorGradleJvmPdf = { module = "org.asciidoctor:asciidoctor-gradle-jvm-pdf", version.ref= "asciidoctor" }
-rouge = { module = "rubygems:rouge", version.ref = "rouge" }
-diagram = { module = "rubygems:asciidoctor-diagram", version.ref = "diagram" }
-
-[bundles]
-logback = ["logbackCore", "logbackClassic"]
-
-[plugins]
-spotbugs = { id = "com.github.spotbugs",  version.ref = "spotbugs" }
-sonarqube = { id = "org.sonarqube", version.ref = "sonarqube" }
-asciidoctorPdf = { id = "org.asciidoctor.jvm.pdf", version.ref = "asciidoctor" }
-asciidoctorConvert = { id = "org.asciidoctor.jvm.convert", version.ref = "asciidoctor" }
-asciidoctorGems = { id = "org.asciidoctor.jvm.gems", version.ref = "asciidoctor" }
-javaConvention = { id = "de.cimt.java-conventions", version.ref = "cimtConventions" }
-applicationConvention  = { id = "de.cimt.application-conventions", version.ref = "cimtConventions" }
-libraryConvention = { id = "de.cimt.library-conventions", version.ref = "cimtConventions" }
-asciidoctorConvention = { id = "de.cimt.asciidoctor-conventions", version.ref = "cimtConventions" }
-spring-boot = { id = "org.springframework.boot", version.ref = "springboot"}
-spring-dependencies = { id  = "io.spring.dependency-management", version.ref = "springdependencies" }
-vaadin = { id = "com.vaadin", version.ref = "vaadin" }
-lombok = { id = "io.freefair.lombok", version.ref = "lombok" }

integration/gradle/wrapper/gradle-wrapper.properties

@@ -1,9 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-bin.zip
-networkTimeout=10000
-retries=0
-retryBackOffMs=500
-validateDistributionUrl=true
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

integration/gradlew

@@ -1,248 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    if ! command -v java >/dev/null 2>&1
-    then
-        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC2039,SC3045
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
-#     and any embedded shellness will be escaped.
-#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
-#     treated as '${Hostname}' itself on the command line.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
-fi
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

integration/gradlew.bat

@@ -1,82 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-@rem SPDX-License-Identifier: Apache-2.0
-@rem
-
-@if "%DEBUG%"=="" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables, and ensure extensions are enabled
-setlocal EnableExtensions
-
-set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-@rem This is normally unused
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-"%COMSPEC%" /c exit 1
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo. 1>&2
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
-echo. 1>&2
-echo Please set the JAVA_HOME variable in your environment to match the 1>&2
-echo location of your Java installation. 1>&2
-
-"%COMSPEC%" /c exit 1
-
-:execute
-@rem Setup the command line
-
-
-
-@rem Execute Gradle
-@rem endlocal doesn't take effect until after the line is parsed and variables are expanded
-@rem which allows us to clear the local environment before executing the java command
-endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
-
-:exitWithErrorLevel
-@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
-"%COMSPEC%" /c exit %ERRORLEVEL%

integration/settings.gradle

@@ -1 +0,0 @@
-rootProject.name = 'integration'

integration/src/main/java/de/thpeetz/kontor/integration/IntegrationApplication.java

@@ -1,13 +0,0 @@
-package de.thpeetz.kontor.integration;
-
-import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.SpringBootApplication;
-
-@SpringBootApplication
-public class IntegrationApplication {
-
-	public static void main(String[] args) {
-		SpringApplication.run(IntegrationApplication.class, args);
-	}
-
-}

integration/src/main/java/de/thpeetz/kontor/integration/routes/AddLinkFromQueue.java

@@ -1,28 +0,0 @@
-package de.thpeetz.kontor.integration.routes;
-
-import de.thpeetz.kontor.integration.services.AddLinkProcessor;
-import de.thpeetz.kontor.media.services.MediaFileService;
-import org.apache.camel.builder.RouteBuilder;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-@Component
-public class AddLinkFromQueue extends RouteBuilder {
-
-    @Autowired
-    private final MediaFileService mediaFileService;
-
-    @Autowired
-    public AddLinkFromQueue(MediaFileService mediaFileService) {
-        this.mediaFileService = mediaFileService;
-    }
-
-    @Override
-    public void configure() throws Exception {
-        from("jms:queue:add_link_file")
-                .routeId("read-queue-add-link_file")
-                .log("${body}")
-                .process(new AddLinkProcessor(mediaFileService))
-                .to("jms:queue:update_title");
-    }
-}

integration/src/main/java/de/thpeetz/kontor/integration/routes/QueueMediaLinkAdd.java

@@ -1,25 +0,0 @@
-package de.thpeetz.kontor.integration.routes;
-import de.thpeetz.kontor.media.services.MediaFileService;
-import org.apache.camel.builder.RouteBuilder;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-@Component
-public class QueueMediaLinkAdd extends RouteBuilder {
-
-    @Autowired
-    private final MediaFileService mediaFileService;
-
-    @Autowired
-    public QueueMediaLinkAdd(MediaFileService mediaFileService) {
-        this.mediaFileService = mediaFileService;
-    }
-
-    @Override
-    public void configure() throws Exception {
-        from("jms:queue:media.link.add")
-                .routeId("read-queue-media-link-add")
-                .log("${body}")
-                .to("jms:queue:media.link.add.processed");
-    }
-}

integration/src/main/java/de/thpeetz/kontor/integration/routes/QueueMediaLoFiAdd.java

@@ -1,26 +0,0 @@
-package de.thpeetz.kontor.integration.routes;
-
-import org.apache.camel.builder.RouteBuilder;
-import de.thpeetz.kontor.media.services.MediaFileService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-@Component
-public class QueueMediaLoFiAdd extends RouteBuilder {
-
-    @Autowired
-    private final MediaFileService mediaFileService;
-
-    @Autowired
-    public QueueMediaLoFiAdd(MediaFileService mediaFileService) {
-        this.mediaFileService = mediaFileService;
-    }
-
-    @Override
-    public void configure() throws Exception {
-        from("jms:queue:media.lofi.add")
-                .routeId("read-queue-media-lofi-add")
-                .log("${body}")
-                .to("jms:queue:media.lofi.add.processed");
-    }
-}

integration/src/main/java/de/thpeetz/kontor/integration/routes/QueueMediaVideoAdd.java

@@ -1,26 +0,0 @@
-package de.thpeetz.kontor.integration.routes;
-
-import org.apache.camel.builder.RouteBuilder;
-import de.thpeetz.kontor.media.services.MediaFileService;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Component;
-
-@Component
-public class QueueMediaVideoAdd extends RouteBuilder {
-
-    @Autowired
-    private final MediaFileService mediaFileService;
-
-    @Autowired
-    public QueueMediaVideoAdd(MediaFileService mediaFileService) {
-        this.mediaFileService = mediaFileService;
-    }
-
-    @Override
-    public void configure() throws Exception {
-        from("jms:queue:media.video.add")
-                .routeId("read-queue-media-video-add")
-                .log("${body}")
-                .to("jms:queue:media.video.add.processed");
-    }
-}

integration/src/main/java/de/thpeetz/kontor/integration/routes/ReadQueueRoute.java

@@ -1,16 +0,0 @@
-package de.thpeetz.kontor.integration.routes;
-
-import org.apache.camel.builder.RouteBuilder;
-import org.springframework.stereotype.Component;
-
-@Component
-public class ReadQueueRoute extends RouteBuilder {
-
-    @Override
-    public void configure() throws Exception {
-        from("jms:queue:KontorMediaFile")
-                .routeId("add-link-from-queue")
-                .trace(true)
-                .log(">>> ${body}");
-    }
-}

integration/src/main/java/de/thpeetz/kontor/integration/services/AddLinkProcessor.java

@@ -1,53 +0,0 @@
-package de.thpeetz.kontor.integration.services;
-
-import com.fasterxml.jackson.core.type.TypeReference;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import de.thpeetz.kontor.media.data.MediaFile;
-import de.thpeetz.kontor.media.services.MediaFileService;
-import lombok.extern.slf4j.Slf4j;
-import org.apache.camel.Exchange;
-import org.apache.camel.Processor;
-
-import java.util.HashMap;
-import java.util.Map;
-
-@Slf4j
-public class AddLinkProcessor implements Processor {
-
-    private final MediaFileService mediaFileService;
-
-    public AddLinkProcessor(MediaFileService mediaFileService) {
-        this.mediaFileService = mediaFileService;
-    }
-
-    @Override
-    public void process(Exchange exchange) throws Exception {
-        ObjectMapper objectMapper = new ObjectMapper();
-        HashMap<String, String> myMap = objectMapper.readValue(exchange.getIn().getBody().toString(),
-                new TypeReference<HashMap<String, String>>() {
-                });
-        String url = myMap.get("url");
-        log.info("found url: {}", url);
-        MediaFile mediaFile = mediaFileService.findAllMediaFilesByUrl(url);
-        if (mediaFile == null) {
-            log.info("URL not found, create MediaFile");
-            mediaFile = new MediaFile();
-            mediaFile.setUrl(url);
-            mediaFile.setPath("");
-            mediaFile.setCloudLink("");
-            mediaFile.setFileName("");
-            mediaFile.setTitle("");
-            mediaFile.setReview(true);
-            mediaFile.setShouldDownload(true);
-            MediaFile mediaFileResult = mediaFileService.saveMediaFile(mediaFile);
-            log.info("created MediaFile with {}", mediaFileResult.getId());
-            exchange.getMessage().getHeaders().put("mediafile_id", mediaFileResult.getId());
-        } else {
-            log.info("found MediaFile with {}", mediaFile.getId());
-            exchange.getMessage().getHeaders().put("mediafile_id", mediaFile.getId());
-        }
-        log.info("found MediaFile: {}", mediaFile);
-        Map<String, Object> map = exchange.getMessage().getHeaders();
-        log.info("Headers: {}", map);
-    }
-}

integration/src/main/java/de/thpeetz/kontor/integration/services/AddLinkService.java

@@ -1,22 +0,0 @@
-package de.thpeetz.kontor.integration.services;
-
-import com.fasterxml.jackson.core.JsonProcessingException;
-import com.fasterxml.jackson.core.type.TypeReference;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-
-import java.util.HashMap;
-
-@Service
-@Slf4j
-public class AddLinkService {
-
-    public void fromQueue(String messageBody) throws JsonProcessingException {
-        log.info("get body: {}", messageBody);
-        ObjectMapper objectMapper = new ObjectMapper();
-        HashMap<String,String> myMap = objectMapper.readValue(messageBody, new TypeReference<HashMap<String,String>>() {});
-        String url = myMap.get("url");
-        log.info("found url: {}", url);
-    }
-}

integration/src/main/resources/application.yaml

@@ -1,6 +0,0 @@
-spring:
-  application:
-    name: integration
-server:
-  port:
-    8110

integration/src/test/java/de/thpeetz/kontor/integration/IntegrationApplicationTests.java

@@ -1,13 +0,0 @@
-package de.thpeetz.kontor.integration;
-
-import org.junit.jupiter.api.Test;
-import org.springframework.boot.test.context.SpringBootTest;
-
-@SpringBootTest
-class IntegrationApplicationTests {
-
-	@Test
-	void contextLoads() {
-	}
-
-}

kontor-api/Containerfile

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

kontor-api/pyproject.toml

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

kontor-api/src/apis/base.py

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,10 +1,10 @@
 from typing import List
 from fastapi import APIRouter, status, HTTPException
 from src.core.log_conf import logger
-from src.db.models.media import MediaActorFile
+from kontor_model.db.models.media import MediaActorFile
-from src.db.repository.media.actorfile import delete_mediaactorfile, import_mediaactorfile
+from kontor_model.db.repository.media.actorfile import delete_mediaactorfile, import_mediaactorfile
 from src.db.session import SessionDep
-from src.schema.media.actorfile import MediaActorFileModel, MediaActorFileResponse, actorfile_to_response
+from kontor_model.schema.media.actorfile import MediaActorFileModel, MediaActorFileResponse, actorfile_to_response
 
 router = APIRouter()
 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

kontor-api/src/core/config.py

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

kontor-api/src/core/security.py

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

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

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

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

@@ -1,27 +0,0 @@
-from typing import Optional
-import uuid
-from datetime import datetime
-
-from sqlalchemy import func
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
-
-
-class Base(DeclarativeBase):
-    pass
-
-
-class BaseMixin:
-    id: Mapped[str] = mapped_column(primary_key=True, default=str(uuid.uuid4()))
-    created_date: Mapped[datetime] = mapped_column(default=func.now())
-    last_modified_date: Mapped[datetime] = mapped_column(default=func.now())
-    version: Mapped[int] = mapped_column(default=0)
-
-
-class BaseVideoMixin:
-    cloud_link: Mapped[Optional[str]]
-    file_name: Mapped[Optional[str]]
-    path: Mapped[str]
-    review: Mapped[bool]
-    title: Mapped[str]
-    url: Mapped[str]
-    should_download: Mapped[bool]

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

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

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

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

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

@@ -1,97 +0,0 @@
-import logging
-import re
-import subprocess
-from datetime import datetime
-from pathlib import Path
-from typing import List, Optional
-
-import requests
-from bs4 import BeautifulSoup
-from sqlalchemy import ForeignKey
-from sqlalchemy.orm import Mapped, relationship, mapped_column
-
-from src.db.models.base import Base, BaseMixin, BaseVideoMixin
-
-
-class MediaFile(Base, BaseMixin, BaseVideoMixin):
-    """
-    MediaFile represents video link.
-    """
-
-    __tablename__ = "media_file"
-    media_actor_files: Mapped[List["MediaActorFile"]] = relationship(
-        back_populates="media_file"
-    )
-
-    def __repr__(self):
-        return f"MediaFile({self.id} {self.title} {self.title})"
-
-    def __str__(self):
-        return f"{self.title}({self.id})"
-
-    def update_title(self):
-        """
-        Update title from url.
-        """
-
-
-class MediaActor(Base, BaseMixin):
-    __tablename__ = "media_actor"
-    name: Mapped[str]
-    url: Mapped[Optional[str]] = mapped_column(unique=True)
-    media_actor_files = relationship("MediaActorFile")
-
-    def __repr__(self) -> str:
-        return f"MediaActor({self.id} {self.name} {self.url})"
-
-    def __str__(self) -> str:
-        return f"{self.url}({self.id})"
-
-
-class MediaActorFile(Base, BaseMixin):
-    __tablename__ = "media_actor_file"
-    media_actor_id: Mapped[str] = mapped_column(
-        ForeignKey("media_actor.id"), nullable=False
-    )
-    media_actor: Mapped[MediaActor] = relationship(back_populates="media_actor_files")
-    media_file_id: Mapped[str] = mapped_column(
-        ForeignKey("media_file.id"), nullable=True
-    )
-    media_file: Mapped[MediaFile] = relationship(back_populates="media_actor_files")
-
-    def __repr__(self):
-        return f"MediaActorFile({self.id} {self.media_actor_id} {self.media_file_id})"
-
-    def __str__(self) -> str:
-        return f"{self.id} {self.media_actor_id} {self.media_file_id}"
-
-
-class MediaArticle(Base, BaseMixin):
-    __tablename__ = "media_article"
-    review: Mapped[bool]
-    title: Mapped[str]
-    url: Mapped[str] = mapped_column(unique=True)
-
-
-class MediaVideo(Base, BaseMixin):
-    """
-    MediaFile represents video link.
-    """
-
-    __tablename__ = "media_video"
-    cloud_link: Mapped[str]
-    file_name: Mapped[str]
-    path: Mapped[str]
-    review: Mapped[bool]
-    title: Mapped[str]
-    url: Mapped[str] = mapped_column(unique=True)
-    should_download: Mapped[bool]
-
-    def __repr__(self):
-        return f"MediaFile({self.id} {self.title} {self.url})"
-
-    def __str__(self):
-        if self.title is None:
-            return f"{self.url}({self.id})"
-        else:
-            return f"{self.title}({self.id})"

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

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

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

@@ -1,18 +0,0 @@
-from typing import Optional
-
-from sqlalchemy.orm import Session
-
-from src.db.models.admin import Profile
-
-
-def get_profile_by_username(username: str, db: Session) -> Optional[Profile]:
-    profile = db.query(Profile).filter(Profile.user_name == username).first()
-    return profile
-
-def get_profile_by_email(email: str, db: Session) -> Optional[Profile]:
-    profile = db.query(Profile).filter(Profile.email == email).first()
-    return profile
-
-def is_database_empty(db: Session) -> bool:
-    profiles = db.query(Profile).all()
-    return len(profiles) == 0

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

@@ -1,47 +0,0 @@
-import uuid
-from typing import List, Optional
-
-from sqlalchemy.orm import Session
-
-from src.core.log_conf import logger
-from src.db.models.comic import Artist
-from src.schema.comics.artist import AddArtist
-from src.schema.comics.artist_details import ArtistDetailResponse, ArtistWorktypeComicResponse, ArtistWorktypeIssueResponse
-from src.schema.comics.comic import ComicResponse
-from src.schema.comics.worktype import WorktypeResponse
-
-
-def get_artist_details(artist: Artist) -> ArtistDetailResponse:
-    comic_works: List[ArtistWorktypeComicResponse] = []
-    comic_works_map = {}
-    for work in artist.comic_works:
-        worktype_id = work.work_type.id
-        if worktype_id in comic_works_map:
-            comic = ComicResponse(id=work.comic.id, title=work.comic.title, completed=work.comic.completed)
-            comic_works_map[worktype_id].comics.append(comic)
-        else:
-            comic_works_map[worktype_id] = ArtistWorktypeComicResponse(
-                worktype=WorktypeResponse(id=worktype_id, name=work.work_type.name),
-                comics=[ComicResponse(id=work.comic.id, title=work.comic.title, completed=work.comic.completed)]
-            )
-    for value in comic_works_map.values():
-        comic_works.append(value)
-    issue_works: List[ArtistWorktypeIssueResponse] = []
-    response = ArtistDetailResponse(
-        id=artist.id,
-        name=str(artist.name),
-        weblink=str(artist.weblink),
-        comic_works=comic_works,
-        issue_works=issue_works,
-    )
-    return response
-
-def update_artist(add_artist: AddArtist, artist_id: str, db: Session) -> Optional[Artist]:
-    logger.info("update artist")
-    artist: Optional[Artist] = db.get(Artist, artist_id)
-    if artist is not None:
-        artist.name = add_artist.name
-        db.add(artist)
-        db.commit()
-        db.refresh(artist)
-    return artist

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

@@ -1,72 +0,0 @@
-from typing import Dict, List, Optional
-
-from sqlalchemy.orm import Session
-
-from src.core.log_conf import logger
-from src.db.models.comic import Comic, Issue
-from src.schema.comics.artist import artist_to_response
-from src.schema.comics.comic import ComicSchema, comic_to_response
-from src.schema.comics.comic_details import ComicDetailsResponse, ComicWorktypeArtistResponse
-from src.schema.comics.issue import IssueResponse, issue_to_response
-from src.schema.comics.issue_details import IssueDetailsResponse
-from src.schema.comics.publisher import publisher_to_response
-from src.schema.comics.volume import VolumeResponse, volume_to_response
-from src.schema.comics.worktype import worktype_to_response
-
-
-def get_issue_details(issue: Issue) -> IssueDetailsResponse:
-    volume = None
-    if issue.volume:
-        volume = volume_to_response(issue.volume)
-    response = IssueDetailsResponse(
-        id=issue.id,
-        issue_number=str(issue.issue_number),
-        in_stock=bool(issue.in_stock),
-        is_read=bool(issue.is_read),
-        comic=comic_to_response(issue.comic),
-        volume=volume
-    )
-    return response
-
-
-def update_comic(new_comic: ComicSchema, comic_id: str, db: Session) -> Optional[Comic]:
-    logger.info(f"update_comic: {new_comic} with {comic_id}")
-    comic: Optional[Comic] = db.get(Comic, comic_id)
-    return comic
-
-def get_comic_details(comic: Comic) -> ComicDetailsResponse:
-    volumes: List[VolumeResponse] = []
-    for volume in comic.volumes:
-        volumes.append(volume_to_response(volume))
-    issues: List[IssueResponse] = []
-    for issue in comic.issues:
-        issues.append(issue_to_response(issue))
-    works: List[ComicWorktypeArtistResponse] = []
-    works_map: Dict[str, ComicWorktypeArtistResponse] = {}
-    for work in comic.comic_works:
-        worktype_id = work.work_type.id
-        if worktype_id in works_map:
-            artist = artist_to_response(work.artist)
-            works_map[worktype_id].artists.append(artist)
-            logger.info(f"add artist to response map: {artist} -> {works_map}")
-            print(f"add artist to response map: {artist} -> {works_map}")
-        else:
-            works_map[worktype_id] = ComicWorktypeArtistResponse(
-                worktype=worktype_to_response(work.work_type),
-                artists=[artist_to_response(work.artist)]
-            )
-    for value in works_map.values():
-        works.append(value)
-    response = ComicDetailsResponse(
-        id=str(comic.id),
-        created=str(comic.created_date),
-        title=str(comic.title),
-        completed=bool(comic.completed),
-        current_order=bool(comic.current_order),
-        weblink=str(comic.weblink),
-        publisher=publisher_to_response(comic.publisher),
-        issues=issues,
-        volumes=volumes,
-        works=works
-    )
-    return response

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

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

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

@@ -1,33 +0,0 @@
-import uuid
-from datetime import datetime
-from typing import AnyStr, Optional
-
-from sqlalchemy.orm import Session
-
-from src.core.log_conf import logger
-from src.db.models.comic import WorkType
-from src.schema.comics.worktype import AddWorkType
-
-
-def create_new_worktype(work: AddWorkType, db: Session) -> WorkType:
-    worktype = WorkType()
-    worktype.id = str(uuid.uuid4())
-    worktype.created_date = datetime.now()
-    worktype.last_modified_date = datetime.now()
-    worktype.name = work.worktype
-    db.add(worktype)
-    db.commit()
-    db.refresh(worktype)
-    logger.info(f"create_new_worktype: {worktype}")
-    return worktype
-
-
-def update_worktype(work: AddWorkType, worktype_id: AnyStr, db: Session) -> Optional[WorkType]:
-    logger.info("update worktype")
-    worktype: Optional[WorkType] = db.get(WorkType, worktype_id)
-    if worktype is not None:
-        worktype.name = work.worktype
-        db.add(worktype)
-        db.commit()
-        db.refresh(worktype)
-    return worktype

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

@@ -1,66 +0,0 @@
-from datetime import datetime
-import uuid
-
-from sqlalchemy.orm import Session
-
-from src.core.log_conf import logger
-from src.db.models.media import MediaActor
-from src.db.repository.media.actorfile import delete_mediaactorfile
-from src.schema.media.actor import MediaActorModel
-
-
-def create_new_mediaactor(new_actor: MediaActorModel, db: Session) -> MediaActor:
-    logger.info(f"create MediaActor with url {new_actor.url}")
-    media_actor: MediaActor = MediaActor()
-    media_actor.id = str(uuid.uuid4())
-    if new_actor.name is not None:
-        media_actor.name = new_actor.name
-    media_actor.url = new_actor.url
-    media_actor.created_date = datetime.now()
-    media_actor.last_modified_date = datetime.now()
-    media_actor.version = 0
-    db.add(media_actor)
-    db.commit()
-    db.refresh(media_actor)
-    logger.info(f"created {media_actor}")
-    return media_actor
-
-def delete_mediaactor(db: Session, actor_id: str):
-    logger.info(f"delete MediaActor with id {actor_id}")
-    media_actor = db.get(MediaActor, actor_id)
-    if media_actor is not None:
-        actor_files = media_actor.media_actor_files
-        for actor_file in actor_files:
-            delete_mediaactorfile(db, actorfile_id=actor_file.id)
-    db.refresh(media_actor)
-    db.delete(media_actor)
-    db.commit()
-
-def import_mediaactor(db: Session, new_actor: MediaActorModel) -> MediaActor:
-    """
-    import MediaFile and set missing values with default ones.
-    """
-    logger.info("import MediaActor with %s", new_actor)
-    media_actor: MediaActor = MediaActor()
-    media_actor.id = new_actor.id
-    if new_actor.created_date:
-        media_actor.created_date = new_actor.created_date
-    else:
-        media_actor.created_date = datetime.now()
-    if new_actor.last_modified_date:
-        media_actor.last_modified_date = new_actor.last_modified_date
-    else:
-        media_actor.last_modified_date = datetime.now()
-    media_actor.version = new_actor.version
-    if new_actor.name:
-        media_actor.name = new_actor.name
-    else:
-        media_actor.name = ""
-    if new_actor.url:
-        media_actor.url = new_actor.url
-    else:
-        media_actor.url = ""
-    db.add(media_actor)
-    db.commit()
-    db.refresh(media_actor)
-    return media_actor

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

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

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

@@ -1,78 +0,0 @@
-from datetime import datetime
-import uuid
-
-from sqlalchemy.orm import Session
-
-from src.core.log_conf import logger
-from src.db.models.media import MediaFile
-from src.schema.media.file import MediaFileModel
-
-
-def create_new_mediafile(link: str, db: Session) -> MediaFile:
-    """
-    Create MediaFile with gievne URL.
-    """
-    logger.info("create MediaFile with url {link}")
-    media_file: MediaFile = MediaFile()
-    media_file.id = str(uuid.uuid4())
-    media_file.url = link
-    media_file.created_date = datetime.now()
-    media_file.last_modified_date = datetime.now()
-    media_file.version = 0
-    media_file.review = True
-    media_file.should_download = True
-    db.add(media_file)
-    db.commit()
-    db.refresh(media_file)
-    logger.info("created %s", media_file)
-    return media_file
-
-
-def delete_mediafile(db: Session, media_file_id: str):
-    """
-    Delete MediaFile with given ID from db.
-    """
-    logger.info("delete MediaFile with id %s", media_file_id)
-    media_file = db.get(MediaFile, media_file_id)
-    db.delete(media_file)
-    db.commit()
-
-
-def import_mediafile(db: Session, new_file: MediaFileModel) -> MediaFile:
-    """
-    import MediaActor and set missing values with defautl ones.
-    """
-    logger.info("import MediaFile with %s", new_file)
-    media_file: MediaFile = MediaFile()
-    media_file.id = new_file.id
-    if new_file.created_date:
-        media_file.created_date = new_file.created_date
-    else:
-        media_file.created_date = datetime.now()
-    if new_file.last_modified_date:
-        media_file.last_modified_date = new_file.last_modified_date
-    else:
-        media_file.last_modified_date = datetime.now()
-    media_file.version = new_file.version
-    if new_file.title:
-        media_file.title = new_file.title
-    else:
-        media_file.title = ""
-    if new_file.file_name:
-        media_file.file_name = new_file.file_name
-    else:
-        media_file.file_name = ""
-    if new_file.cloud_link:
-        media_file.cloud_link = new_file.cloud_link
-    else:
-        media_file.cloud_link = ""
-    if new_file.url:
-        media_file.url = new_file.url
-    else:
-        media_file.url = ""
-    media_file.review = new_file.review
-    media_file.should_download = new_file.should_download
-    db.add(media_file)
-    db.commit()
-    db.refresh(media_file)
-    return media_file

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

@@ -1,23 +0,0 @@
-from datetime import datetime
-import uuid
-
-from sqlalchemy.orm import Session
-
-from src.db.models.media import MediaVideo
-from src.webapps.media.forms import AddLinkForm
-
-
-def create_new_video(video: AddLinkForm, db: Session) -> MediaVideo:
-    print(video.url)
-    media_video = MediaVideo()
-    media_video.id = str(uuid.uuid4())
-    media_video.url = str(video.url)
-    media_video.created_date = datetime.now()
-    media_video.last_modified_date = datetime.now()
-    media_video.review = True
-    media_video.should_download = True
-    db.add(media_video)
-    db.commit()
-    db.refresh(media_video)
-    print(media_video)
-    return media_video

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

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

kontor-api/src/main.py

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

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

@@ -1,34 +0,0 @@
-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=account.host,
-        port=account.port,
-        protocol=account.protocol,
-        user_name=account.user_name,
-        password=account.password,
-        start_tls=account.start_tls,
-    )
-    return response

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

@@ -1,23 +0,0 @@
-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=article.title
-    )
-    return response

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

@@ -1,25 +0,0 @@
-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=articleauthor.article_id,
-            author_id=articleauthor.author_id
-    )
-    return response

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

@@ -1,25 +0,0 @@
-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=author.first_name,
-            last_name=author.last_name
-    )
-    return response

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

@@ -1,29 +0,0 @@
-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=book.isbn,
-            title=book.title,
-            year=book.year,
-            publisher_id=book.publisher_id
-    )
-    return response

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

@@ -1,25 +0,0 @@
-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=bookauthor.author_id,
-            book_id=bookauthor.book_id
-    )
-    return response

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

@@ -1,23 +0,0 @@
-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=publisher.name
-    )
-    return response

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

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

@@ -1,22 +0,0 @@
-from typing import List
-from pydantic import BaseModel
-
-from src.schema.comics.comic import ComicResponse
-from src.schema.comics.issue_details import IssueDetailsResponse
-from src.schema.comics.worktype import WorktypeResponse
-
-
-class ArtistWorktypeComicResponse(BaseModel):
-    worktype: WorktypeResponse
-    comics: List[ComicResponse]
-
-class ArtistWorktypeIssueResponse(BaseModel):
-    worktype: WorktypeResponse
-    issues: List[IssueDetailsResponse]
-
-class ArtistDetailResponse(BaseModel):
-    id: str
-    name: str
-    weblink: str
-    comic_works: List[ArtistWorktypeComicResponse]
-    issue_works: List[ArtistWorktypeIssueResponse]

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

@@ -1,48 +0,0 @@
-"""
-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=comic.title,
-            publisher_id=comic.publisher_id,
-            current_order=comic.current_order,
-            completed=comic.completed,
-            weblink=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

@@ -1,26 +0,0 @@
-from typing import List
-from pydantic import BaseModel
-
-from src.schema.comics.artist import ArtistResponse
-from src.schema.comics.issue import IssueResponse
-from src.schema.comics.publisher import PublisherResponse
-from src.schema.comics.volume import VolumeResponse
-from src.schema.comics.worktype import WorktypeResponse
-
-
-class ComicWorktypeArtistResponse(BaseModel):
-    worktype: WorktypeResponse
-    artists: List[ArtistResponse]
-
-
-class ComicDetailsResponse(BaseModel):
-    id: str
-    created: str
-    title: str
-    completed : bool
-    current_order : bool
-    weblink: str
-    publisher: PublisherResponse
-    issues: List[IssueResponse]
-    volumes: List[VolumeResponse]
-    works: List[ComicWorktypeArtistResponse]

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

@@ -1,32 +0,0 @@
-"""
-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=comicwork.comic_id,
-        artist_id=comicwork.artist_id,
-        work_type_id=comicwork.work_type_id,
-    )
-    return response

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

@@ -1,38 +0,0 @@
-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=issue.issue_number,
-        title=issue.title,
-        published_on=issue.published_on,
-        in_stock=issue.in_stock,
-        is_read=issue.is_read,
-        comic_id=issue.comic_id,
-        volume_id=issue.volume_id,
-        story_arc_id=issue.story_arc_id
-    )
-    return response

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

@@ -1,14 +0,0 @@
-from pydantic import BaseModel
-
-from src.schema.comics.comic import ComicResponse
-from src.schema.comics.volume import VolumeResponse
-
-
-class IssueDetailsResponse(BaseModel):
-    id: str
-    issue_number: str
-    in_stock: bool
-    is_read: bool
-    comic: ComicResponse
-    volume: VolumeResponse | None
-

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

@@ -1,32 +0,0 @@
-"""
-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=issuework.issue_id,
-        artist_id=issuework.artist_id,
-        work_type_id=issuework.work_type_id,
-    )
-    return response

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

@@ -1,30 +0,0 @@
-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=publisher.name,
-            weblink=publisher.weblink,
-            parent_publisher_id=publisher.parent_publisher_id
-    )
-    return response
-

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

@@ -1,14 +0,0 @@
-from typing import List
-
-from pydantic import BaseModel
-
-from src.schema.comics.comic import ComicResponse
-from src.schema.comics.publisher import PublisherResponse
-
-
-class PublisherDetailsResponse(BaseModel):
-    id: str
-    name: str
-    parent_publisher: PublisherResponse | None
-    imprints: List[PublisherResponse]
-    comics: List[ComicResponse]

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

@@ -1,30 +0,0 @@
-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=storyarc.name,
-        comic_id=storyarc.comic_id,
-        volume_id=storyarc.volume_id
-    )
-    return response

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

@@ -1,25 +0,0 @@
-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=volume.name,
-        comic_id=volume.comic_id
-    )
-    return response

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

@@ -1,26 +0,0 @@
-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=worktype.name
-    )
-    return response

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

@@ -1,34 +0,0 @@
-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=actor.name,
-        url=actor.url        
-    )
-    return response
-
-
-class MediaActorModel(BaseModel):
-    id: str
-    created_date: datetime
-    last_modified_date: datetime
-    version: int
-    name: Optional[str]
-    url: Optional[str]