complete MetaDataTable and MetaDataColumn

python/kontor-schema/kontor_schema/__init__.py

@@ -5,10 +5,12 @@ import uuid
 from datetime import datetime
 from pathlib import Path
 
+import requests
 from sqlalchemy import Engine
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import sessionmaker
 
+from .admin import User, Token, Role, AuthorizationMatrix, ModuleData, MailAccount, Mail
 from .bookshelf import Article, Book, Author, BookshelfPublisher, ArticleAuthor, BookAuthor
 from .comic import Comic, Artist, Publisher, Issue, StoryArc, TradePaperback, Volume, ComicWork, WorkType
 from .metadata import MetaDataTable, MetaDataColumn
@@ -51,8 +53,15 @@ class KontorDB:
         self.registry['media_file'] = MediaFile
         self.registry['media_article'] = MediaArticle
         self.registry['media_video'] = MediaVideo
-        self.registry['meta_data_table'] = MetaDataTable
+        self.registry[MetaDataTable.__tablename__] = MetaDataTable
         self.registry[MetaDataColumn.__tablename__] = MetaDataColumn
+        self.registry[User.__tablename__] = User
+        self.registry[Token.__tablename__] = Token
+        self.registry[Role.__tablename__] = Role
+        self.registry[AuthorizationMatrix.__tablename__] = AuthorizationMatrix
+        self.registry[ModuleData.__tablename__] = ModuleData
+        self.registry[MailAccount.__tablename__] = MailAccount
+        self.registry[Mail.__tablename__] = Mail
 
     def get_table_names(self) -> list:
         result = []
@@ -87,6 +96,17 @@ class KontorDB:
                     order += 1
             return meta_data
 
+    def get_columns(self, table_name: str) -> dict:
+        columns = {}
+        order = 0
+        __session__ = sessionmaker(self.engine)
+        with __session__() as session:
+            for (_, column) in (session.query(MetaDataTable, MetaDataColumn).
+                    filter(MetaDataTable.id == MetaDataColumn.table_id).
+                    filter(MetaDataTable.table_name == table_name).all()):
+                columns[column.column_name] = {"order": column.column_order, "type": column.column_type}
+        return columns
+
     def get_filters(self, table_name):
         _filter_map = {}
         __session__ = sessionmaker(self.engine)
@@ -300,6 +320,21 @@ class KontorDB:
                 link.review = 0
                 session.commit()
 
+    def get_update_list(self) -> list[str]:
+        self.log.debug("get links marked as review")
+        update_list = []
+        __session__ = sessionmaker(self.engine)
+        with __session__() as session:
+            links = session.query(MediaFile).filter(MediaFile.review == 1).all()
+            for link in links:
+                url = link.url
+                if url is None:
+                    self.log.info(f"url has not been set for {link.id}")
+                    continue
+                update_list.append(url)
+        self.log.debug(f"found {len(update_list)} urls for updates")
+        return update_list
+
     def get_download_list(self) -> list[str]:
         self.log.debug("get links marked as should_download")
         download_list = []

python/kontor-schema/kontor_schema/admin.py

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

python/kontor-schema/kontor_schema/base.py

@@ -1,7 +1,7 @@
 import uuid
 from datetime import datetime
 
-from sqlalchemy import Integer, func, String
+from sqlalchemy import func
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
 

python/kontor-schema/kontor_schema/metadata.py

@@ -19,11 +19,11 @@ class MetaDataTable(Base, BaseMixin):
 
 class MetaDataColumn(Base, BaseMixin):
     __tablename__ = 'meta_data_column'
-    column_modifier = Column(String(255), nullable=True)
-    column_name = Column(String(255))
-    column_order = Column(Integer)
+    column_name = Column(String(255), nullable=False)
     column_sync_name = Column(String(255))
     column_type = Column(String(255))
+    column_modifier = Column(String(255), nullable=True)
+    column_order = Column(Integer)
     table_id = Column(String, ForeignKey('meta_data_table.id'))
     table = relationship("MetaDataTable", back_populates="table_columns")
     column_label = Column(String(255))