tpeetz/kontor
1
0
Fork 0
Code Issues 6 Pull Requests 2 Actions Packages Projects Releases 2 Wiki Activity

remove MetaDataTable and MetaDataColumn to cleanup schema

Browse Source
This commit is contained in:
Thomas Peetz
2025-05-23 18:21:41 +02:00
parent 8cfb60f9a1
commit 456162da44
34 changed files with 536 additions and 1354 deletions
Download Patch File Download Diff File Expand all files Collapse all files
kontor-api/src/apis/base.py
+1 -2
View File
@@ -1,10 +1,9 @@
from fastapi import APIRouter
from src.apis.version1 import comic, media, tysc, admin, metadata
from src.apis.version1 import comic, media, tysc, admin
api_router = APIRouter(prefix="/api")
api_router.include_router(comic.router, prefix="/comics", tags=["comics"])
api_router.include_router(media.router, prefix="/media", tags=["media"])
api_router.include_router(tysc.router, prefix="/tysc", tags=["tysc"])
api_router.include_router(admin.router, prefix="/login", tags=["login"])
api_router.include_router(metadata.router, prefix="/metadata", tags=["metadata"])
kontor-api/src/apis/version1/metadata.py
-26
View File
@@ -1,26 +0,0 @@
from typing import List
from fastapi import APIRouter
from src.apis.utils import SessionDep
from src.db.models.metadata import MetaDataTable, MetaDataColumn
from src.db.repository.metadata import get_tables, get_columns
from src.schema.admin import MetaDataTableResponse, MetaDataColumnResponse
router = APIRouter()
@router.get("/tables")
def get_meta_data_tables(db: SessionDep) -> List[MetaDataTableResponse]:
tables = db.query(MetaDataTable).all()
response: List[MetaDataTableResponse] = get_tables(tables)
return response
@router.get("/columns")
def get_meta_data_columns(db: SessionDep) -> List[MetaDataColumnResponse]:
columns = db.query(MetaDataColumn).all()
response: List[MetaDataColumnResponse] = get_columns(columns)
return response
kontor-api/src/db/models/metadata.py
-39
View File
@@ -1,39 +0,0 @@
from sqlalchemy import Column, String, ForeignKey, Integer, Boolean
from sqlalchemy.orm import relationship
from src.db.models.base import Base, BaseMixin
class MetaDataTable(Base, BaseMixin):
__tablename__ = 'meta_data_table'
table_name = Column(String, unique=True)
table_columns = relationship("MetaDataColumn")
def __repr__(self):
return f'MetaDataTable({self.id} {self.table_name})'
def __str__(self):
return f'{self.table_name}({self.id})'
class MetaDataColumn(Base, BaseMixin):
__tablename__ = 'meta_data_column'
column_name = Column(String, nullable=False)
column_type = Column(String)
column_order = Column(Integer)
is_shown = Column(Boolean)
column_label = Column(String)
show_filter = Column(Boolean)
filter_label = Column(String)
ref_column = Column(String, nullable=True)
table_id = Column(String, ForeignKey('meta_data_table.id'))
table = relationship("MetaDataTable", back_populates="table_columns")
def __repr__(self):
if self.column_name is None:
return f'MetaDataColumn({self.id} {self.table.table_name}.__)'
else:
return f'MetaDataColumn({self.id} {self.table.table_name}.{self.column_name})'
def __str__(self):
return f'{self.column_name}({self.id})'
kontor-api/src/db/repository/metadata.py
-30
View File
@@ -1,30 +0,0 @@
from typing import List
from src.db.models.metadata import MetaDataTable, MetaDataColumn
from src.schema.admin import MetaDataTableResponse, MetaDataColumnResponse
def get_tables(tables: List[MetaDataTable]) -> List[MetaDataTableResponse]:
results: List[MetaDataTableResponse] = []
for table in tables:
result = MetaDataTableResponse(id=table.id, name=table.table_name)
results.append(result)
return results
def get_columns(columns: List[MetaDataColumn]) -> List[MetaDataColumnResponse]:
results: List[MetaDataColumnResponse] = []
for column in columns:
result = MetaDataColumnResponse(
id=column.id,
table_name=column.table.table_name,
column_name=column.column_name,
column_type=column.column_type,
column_order=column.column_order,
is_shown=column.is_shown,
column_label=column.column_label,
show_filter=column.show_filter,
filter_label=column.filter_label,
ref_column=column.ref_column
)
results.append(result)
return results
kontor-api/src/schema/admin.py
-18
View File
@@ -6,21 +6,3 @@ from pydantic import BaseModel
class Token(BaseModel):
access_token: str
token_type: str
class MetaDataTableResponse(BaseModel):
id: str
name: str
class MetaDataColumnResponse(BaseModel):
id: str
table_name: str
column_name: str
column_sync_name: str
column_type: str
column_modifier: Optional[str]
column_order: int
is_shown: bool
column_label: Optional[str]
show_filter: bool
filter_label: Optional[str]
ref_column: Optional[str]
kontor-api/src/templates/admin/metadata.html
-21
View File
@@ -1,21 +0,0 @@
{% extends "shared/base.html" %}
{% block title %}
<title>MetaData</title>
{% endblock %}
{% block content %}
{% with msg=msg %}
{% include "components/alerts.html" %}
{% endwith %}
<div class="container">
{% for table in data %}
<div class="row">
{% with obj=table %}
{% include "components/metadatatable_cards.html" %}
{% endwith %}
<br>
</div>
{% endfor %}
</div>
{% endblock %}
kontor-api/src/templates/admin/permissions.html
+38
View File
@@ -0,0 +1,38 @@
{% extends "shared/base.html" %}
{% block title %}
<title>Permissions</title>
{% endblock %}
{% block content %}
{% with msg=msg %}
{% include "components/alerts.html" %}
{% endwith %}
<div class="container">
<div class="row">
<div class="col">
<h1 class="display-5">Permissions..</h1>
</div>
</div>
<div class="row">
<table class="table table-hover">
<thead><tr>
<th scope="col">Name</th>
<th colspan="2">Actions</th>
</tr></thead>
<tbody>
{% for permission in permissions %}
<tr>
<th scope="row"><a href="/admins/permissions/{{permission.id}}">{{permission.name}}</a></th>
<td><a href="/admin/permission/edit/{{permission.id}}" class="btn btn-outline-primary btn-sm active" role="button" aria-pressed="true">Edit</a></td>
<td><a href="/admin/permission/delete/{{permission.id}}" class="btn btn-outline-danger btn-sm active" role="button" aria-pressed="true">Delete</a></td>
</tr>
{% endfor %}
</tbody>
</table>
<div>
<a href="/admin/permission/add" class="btn btn-outline-primary btn-sm active" role="button" aria-pressed="true">Add Permission</a>
</div>
</div>
</div>
{% endblock %}
kontor-api/src/templates/admin/profiles.html
+43
View File
@@ -0,0 +1,43 @@
{% extends "shared/base.html" %}
{% block title %}
<title>Profiles</title>
{% endblock %}
{% block content %}
{% with msg=msg %}
{% include "components/alerts.html" %}
{% endwith %}
<div class="container">
<div class="row">
<div class="col">
<h1 class="display-5">Profiles..</h1>
</div>
</div>
<div class="row">
<table class="table table-hover">
<thead><tr>
<th scope="col">Username</th>
<th scope="col">First Name</th>
<th scope="col">Last Name</th>
<th colspan="2">Actions</th>
</tr></thead>
<tbody>
{% for profile in profiles %}
<tr>
<th scope="row"><a href="/admins/profiles/{{profile.id}}">{{profile.user_name}}</a></th>
<th scope="row">{{profile.first_name}}</th>
<th scope="row">{{profile.last_name}}</th>
<th scope="row">{{profile.email}}</th>
<td><a href="/admin/profile/edit/{{profile.id}}" class="btn btn-outline-primary btn-sm active" role="button" aria-pressed="true">Edit</a></td>
<td><a href="/admin/profile/delete/{{profile.id}}" class="btn btn-outline-danger btn-sm active" role="button" aria-pressed="true">Delete</a></td>
</tr>
{% endfor %}
</tbody>
</table>
<div>
<a href="/admin/profile/add" class="btn btn-outline-primary btn-sm active" role="button" aria-pressed="true">Add Profile</a>
</div>
</div>
</div>
{% endblock %}
kontor-api/src/templates/comic/comics.html
+3 -1
View File
@@ -34,7 +34,9 @@
{% endfor %}
</tbody>
</table>
<a href="/comic/comic/add" class="btn btn-outline-primary btn-sm active" role="button" aria-pressed="true">Add Comic</a>
<div>
<a href="/comic/comic/add" class="btn btn-outline-primary btn-sm active" role="button" aria-pressed="true">Add Comic</a>
</div>
</div>
</div>
{% endblock %}
kontor-api/src/templates/components/metadatatable_cards.html
-31
View File
@@ -1,31 +0,0 @@
<div class="card shadow p-3 mb-2 bg-body rounded">
<div class="card-body">
<h5 class="card-title">{{obj.table_name}}</h5>
<table class="table table-hover">
<thead><tr>
<th scope="col">Column Name</th>
<th scope="col">Column Type</th>
<th scope="col">Column Order</th>
<th scope="col">Is Shown</th>
<th scope="col">Column Label</th>
<th scope="col">Show Filter</th>
<th scope="col">Filter Label</th>
<th scope="col">Ref Column</th>
</tr></thead>
<tbody>
{% for column in obj.table_columns %}
<tr>
<th scope="row"><a href="/admin/metadata/{{column.id}}">{{column.column_name}}</a></th>
<td>{{column.column_type}}</td>
<td>{{column.column_order}}</td>
<td>{% with check=column.is_shown %}{% include "components/check.html" %}{% endwith %}</td>
<td>{{column.column_label}}</td>
<td>{% with check=column.show_filter %}{% include "components/check.html" %}{% endwith %}</td>
<td>{{column.filter_label}}</td>
<td>{{column.ref_column}}</td>
</tr>
{% endfor %}
</tbody>
</table>
</div>
</div>
kontor-api/src/templates/components/navbar.html
+2 -1
View File
@@ -41,7 +41,8 @@
<li><a class="dropdown-item" href="/register/">Signup</a></li>
<li><a class="dropdown-item" href="/login/">Login</a></li>
<li><hr class="dropdown-divider"></li>
<li><a class="dropdown-item" href="/admin/metadata">MetaData</a></li>
<li><a class="dropdown-item" href="/admin/profiles">Profiles</a></li>
<li><a class="dropdown-item" href="/admin/permissions">Permissions</a></li>
</ul>
</li>
</ul>
kontor-api/src/webapps/admin/route_admin.py
+21 -14
View File
@@ -1,24 +1,31 @@
from typing import AnyStr
from fastapi import APIRouter, Request
from fastapi.security.utils import get_authorization_scheme_param
from fastapi.templating import Jinja2Templates
from src.apis.utils import SessionDep
from src.apis.version1.admin import get_current_user_from_token
from src.db.models.admin import Profile
from src.db.models.metadata import MetaDataColumn, MetaDataTable
from src.db.repository.metadata import get_columns
from src.db.models.admin import Permission, Profile
templates = Jinja2Templates(directory="src/templates")
router = APIRouter(include_in_schema=False, prefix="/admin")
@router.get("/metadata")
def get_metadata(db: SessionDep, request: Request, msg: str = None):
token = request.cookies.get("access_token")
scheme, param = get_authorization_scheme_param(token)
current_user: Profile = get_current_user_from_token(token=param, db=db)
data = []
if current_user is None:
msg = "You are not logged in"
return templates.TemplateResponse("admin/metadata.html", {"request": request, "msg": msg, "data": data})
tables= db.query(MetaDataTable).all()
return templates.TemplateResponse("admin/metadata.html", {"request": request, "msg": msg, "data": tables})
@router.get("/profiles")
def get_profiles(db: SessionDep, request: Request, msg: str | None = None):
profiles = db.query(Profile).all()
return templates.TemplateResponse("admin/profiles.html", {"request": request, "msg": msg, "profiles": profiles})
@router.get("/profiles/{profile_id}")
def comic_details(profile_id: AnyStr, request: Request, db: SessionDep):
profile = db.get(Profile, profile_id)
return templates.TemplateResponse("admin/profile_detail.html", {"request": request, "profile":profile})
@router.get("/permissions")
def get_permissions(db: SessionDep, request: Request, msg: str | None = None):
permissions = db.query(Permission).all()
return templates.TemplateResponse("admin/permissions.html", {"request": request, "msg": msg, "permissions": permissions})
@router.get("/permissions/{permission_id}")
def artist_detail(permission_id: AnyStr, request: Request, db: SessionDep):
permission= db.get(Permission, str(permission_id))
return templates.TemplateResponse("comic/permission_detail.html", {"request": request, "permission": permission})
kontor-api/src/webapps/comic/route_comics.py
+2 -8
View File
@@ -1,16 +1,10 @@
from fastapi import APIRouter, Request, responses, status
from fastapi import APIRouter, Request
from fastapi.templating import Jinja2Templates
from fastapi.responses import RedirectResponse
from src.apis.utils import SessionDep
from src.db.models.comic import Comic, Artist, Publisher, Issue, WorkType
from src.db.models.comic import Comic, Artist, Publisher, Issue
from typing import AnyStr
from src.db.repository.comic import create_new_worktype, update_worktype
from src.main import logger
from src.schema.comics.worktype import AddWorkType
from src.webapps.comic.forms import AddWorktypeForm
templates = Jinja2Templates(directory="src/templates")
router = APIRouter(include_in_schema=False, prefix="/comic")
kontor-scripts/db/models/__init__.py
+18 -21
View File
@@ -33,7 +33,6 @@ from db.models.media import (
MediaArticle,
MediaVideo,
)
from db.models.metadata import MetaDataColumn, MetaDataTable
from db.models.tysc import (
Card,
CardSet,
@@ -46,40 +45,38 @@ from db.models.tysc import (
)
registry = {
Card.__tablename__: Card,
CardSet.__tablename__: CardSet,
Rooster.__tablename__: Rooster,
Sport.__tablename__: Sport,
Player.__tablename__: Player,
Team.__tablename__: Team,
FieldPosition.__tablename__: FieldPosition,
Player.__tablename__: Player,
Vendor.__tablename__: Vendor,
Sport.__tablename__: Sport,
Issue.__tablename__: Issue,
TradePaperback.__tablename__: TradePaperback,
StoryArc.__tablename__: StoryArc,
Volume.__tablename__: Volume,
ComicWork.__tablename__: ComicWork,
CardSet.__tablename__: CardSet,
Card.__tablename__: Card,
Rooster.__tablename__: Rooster,
Artist.__tablename__: Artist,
Comic.__tablename__: Comic,
Publisher.__tablename__: Publisher,
WorkType.__tablename__: WorkType,
ArticleAuthor.__tablename__: ArticleAuthor,
BookAuthor.__tablename__: BookAuthor,
BookshelfPublisher.__tablename__: BookshelfPublisher,
Comic.__tablename__: Comic,
Volume.__tablename__: Volume,
StoryArc.__tablename__: StoryArc,
Issue.__tablename__: Issue,
TradePaperback.__tablename__: TradePaperback,
ComicWork.__tablename__: ComicWork,
Article.__tablename__: Article,
BookshelfPublisher.__tablename__: BookshelfPublisher,
Book.__tablename__: Book,
Author.__tablename__: Author,
ArticleAuthor.__tablename__: ArticleAuthor,
BookAuthor.__tablename__: BookAuthor,
MediaArticle.__tablename__: MediaArticle,
MediaVideo.__tablename__: MediaVideo,
MediaFile.__tablename__: MediaFile,
MediaActor.__tablename__: MediaActor,
MediaActorFile.__tablename__: MediaActorFile,
MediaArticle.__tablename__: MediaArticle,
MediaVideo.__tablename__: MediaVideo,
MetaDataColumn.__tablename__: MetaDataColumn,
MetaDataTable.__tablename__: MetaDataTable,
Assignment.__tablename__: Assignment,
Token.__tablename__: Token,
Profile.__tablename__: Profile,
Permission.__tablename__: Permission,
Assignment.__tablename__: Assignment,
Token.__tablename__: Token,
ModuleData.__tablename__: ModuleData,
MailAccount.__tablename__: MailAccount,
Mail.__tablename__: Mail
kontor-scripts/db/models/admin.py
+82 -1
View File
@@ -40,6 +40,20 @@ class Profile(Base, BaseMixin):
self.password = import_data['password']
self.enabled = import_data['enabled']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['first_name'] = self.first_name
item['last_name'] = self.last_name
item['user_name'] = self.user_name
item['email'] = self.email
item['password'] = self.password
item['enabled'] = self.enabled
return item
class Token(Base, BaseMixin):
__tablename__ = "token"
@@ -60,7 +74,19 @@ class Token(Base, BaseMixin):
self.last_used_date = import_data['last_used_date']
self.enabled = import_data['enabled']
self.profile_id = import_data['profile_id']
self.password = import_data['password']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['token'] = self.token
item['name'] = self.name
item['last_used_date'] = self.last_used_date
item['enabled'] = self.enabled
item['profile_id'] = self.profile_id
return item
class Permission(Base, BaseMixin):
@@ -75,6 +101,14 @@ class Permission(Base, BaseMixin):
self.version = import_data['version']
self.name = import_data['name']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
return item
class Assignment(Base, BaseMixin):
__tablename__ = "assignment"
@@ -91,6 +125,16 @@ class Assignment(Base, BaseMixin):
self.profile_id = import_data['profile_id']
self.permission_id = import_data['permission_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['profile_id'] = self.profile_id
item['permission_id'] = self.permission_id
return item
class ModuleData(Base, BaseMixin):
__tablename__ = "module_data"
@@ -105,6 +149,16 @@ class ModuleData(Base, BaseMixin):
self.module_name = import_data['module_name']
self.import_data = import_data['import_data']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['module_name'] = self.module_name
item['import_data'] = self.import_data
return item
class MailAccount(Base, BaseMixin):
__tablename__ = "mail_account"
@@ -127,6 +181,20 @@ class MailAccount(Base, BaseMixin):
self.password = import_data['password']
self.start_tls = import_data['start_tls']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['host'] = self.host
item['port'] = self.port
item['protocol'] = self.protocol
item['user_name'] = self.user_name
item['password'] = self.password
item['start_tls'] = self.start_tls
return item
class Mail(Base, BaseMixin):
__tablename__ = "mail"
@@ -146,3 +214,16 @@ class Mail(Base, BaseMixin):
self.body = import_data['body']
self.sent_date = import_data['sent_date']
self.received_date = import_data['received_date']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['folder'] = self.folder
item['subject'] = self.subject
item['body'] = self.body
item['sent_date'] = str(self.sent_date)
item['received_date'] = str(self.received_date)
return item
kontor-scripts/db/models/bookshelf.py
+60
View File
@@ -17,6 +17,15 @@ class Article(Base, BaseMixin):
self.version = import_data['version']
self.title = import_data['title']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['title'] = self.title
return item
class Author(Base, BaseMixin):
__tablename__ = 'author'
@@ -33,6 +42,16 @@ class Author(Base, BaseMixin):
self.first_name = import_data['first_name']
self.last_name = import_data['last_name']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['first_name'] = self.first_name
item['last_name'] = self.last_name
return item
class BookshelfPublisher(Base, BaseMixin):
__tablename__ = 'bookshelf_publisher'
@@ -46,6 +65,15 @@ class BookshelfPublisher(Base, BaseMixin):
self.version = import_data['version']
self.name = import_data['name']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
return item
class Book(Base, BaseMixin):
__tablename__ = 'book'
@@ -66,6 +94,18 @@ class Book(Base, BaseMixin):
self.year = import_data['year']
self.publisher_id = import_data['publisher_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['isbn'] = self.isbn
item['title'] = self.title
item['year'] = self.year
item['publisher_id'] = self.publisher_id
return item
class ArticleAuthor(Base, BaseMixin):
__tablename__ = 'article_author'
@@ -82,6 +122,16 @@ class ArticleAuthor(Base, BaseMixin):
self.article_id = import_data['article_id']
self.author_id = import_data['author_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['article_id'] = self.article_id
item['author_id'] = self.author_id
return item
class BookAuthor(Base, BaseMixin):
__tablename__ = 'book_author'
@@ -97,3 +147,13 @@ class BookAuthor(Base, BaseMixin):
self.version = import_data['version']
self.author_id = import_data['author_id']
self.book_id = import_data['book_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['author_id'] = self.author_id
item['book_id'] = self.book_id
return item
kontor-scripts/db/models/comic.py
+100
View File
@@ -34,6 +34,17 @@ class Publisher(Base):
self.name = import_data['name']
self.parent_publisher_id = import_data['parent_publisher_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
item['weblink'] = self.weblink
item['parent_publisher_id'] = self.parent_publisher_id
return item
class Comic(Base, BaseMixin):
__tablename__ = 'comic'
@@ -67,6 +78,19 @@ class Comic(Base, BaseMixin):
if 'weblink' in import_data:
self.weblink = import_data['weblink']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['title'] = self.title
item['publisher_id'] = self.publisher_id
item['current_order'] = self.current_order
item['completed'] = self.completed
item['weblink'] = self.weblink
return item
class Volume(Base, BaseMixin):
__tablename__ = "volume"
@@ -84,6 +108,15 @@ class Volume(Base, BaseMixin):
self.name = import_data['name']
self.comic_id = import_data['comic_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
item['comic_id'] = self.comic_id
return item
class TradePaperback(Base, BaseMixin):
__tablename__ = "trade_paperback"
@@ -103,6 +136,18 @@ class TradePaperback(Base, BaseMixin):
self.issue_end = import_data['issue_end']
self.comic_id = import_data['comic_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
item['issue_start'] = self.issue_start
item['issue_end'] = self.issue_end
item['comic_id'] = self.comic_id
return item
class StoryArc(Base, BaseMixin):
__tablename__ = "story_arc"
@@ -122,6 +167,17 @@ class StoryArc(Base, BaseMixin):
self.comic_id = import_data['comic_id']
self.volume_id = import_data['volume_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
item['comic_id'] = self.comic_id
item['volume_id'] = self.volume_id
return item
class Issue(Base, BaseMixin):
__tablename__ = "issue"
@@ -147,6 +203,20 @@ class Issue(Base, BaseMixin):
self.volume_id = import_data['volume_id']
self.story_arc_id = import_data['story_arc_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['issue_number'] = self.issue_number
item['in_stock'] = self.in_stock
item['is_read'] = self.is_read
item['comic_id'] = self.comic_id
item['volume_id'] = self.volume_id
item['story_arc_id'] = self.story_arc_id
return item
class Artist(Base, BaseMixin):
__tablename__ = "artist"
@@ -163,6 +233,16 @@ class Artist(Base, BaseMixin):
if 'weblink' in import_data:
self.weblink = import_data['weblink']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
item['weblink'] = self.weblink
return item
class WorkType(Base, BaseMixin):
__tablename__ = "worktype"
@@ -182,6 +262,15 @@ class WorkType(Base, BaseMixin):
self.version = import_data['version']
self.name = import_data['name']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
return item
class ComicWork(Base, BaseMixin):
__tablename__ = "comic_work"
@@ -200,3 +289,14 @@ class ComicWork(Base, BaseMixin):
self.comic_id = import_data['comic_id']
self.artist_id = import_data['artist_id']
self.work_type_id = import_data['work_type_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['comic_id'] = self.comic_id
item['artist_id'] = self.artist_id
item['work_type_id'] = self.work_type_id
return item
kontor-scripts/db/models/media.py
+61 -2
View File
@@ -34,6 +34,21 @@ class MediaFile(Base, BaseMixin, BaseVideoMixin):
self.url = import_data['url']
self.should_download = import_data['should_download']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['cloud_link'] = self.cloud_link
item['file_name'] = self.file_name
item['path'] = self.path
item['review'] = self.review
item['title'] = self.title
item['url'] = self.url
item['should_download'] = self.should_download
return item
def update_title(self) -> None:
print(f"update title for {self.url}")
try:
@@ -41,7 +56,7 @@ class MediaFile(Base, BaseMixin, BaseVideoMixin):
soup = BeautifulSoup(r.content, "html.parser")
title = soup.title.string
self.title = title
self.review = False_
self.review = False
except:
self.title = None
self.review = True
@@ -61,7 +76,7 @@ class MediaFile(Base, BaseMixin, BaseVideoMixin):
self.file_name = None
else:
download_file = Path(file_name)
self.should_download = False_
self.should_download = False
self.file_name = download_file.name
self.cloud_link = str(download_file.absolute())
self.last_modified_date = datetime.now()
@@ -92,6 +107,15 @@ class MediaActor(Base, BaseMixin):
self.version = import_data['version']
self.name = import_data['name']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
return item
class MediaActorFile(Base, BaseMixin):
__tablename__ = 'media_actor_file'
@@ -108,6 +132,15 @@ class MediaActorFile(Base, BaseMixin):
self.media_actor_id = import_data['media_actor_id']
self.media_file_id = import_data['media_file_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['media_actor_id'] = self.media_actor_id
item['media_file_id'] = self.media_file_id
return item
class MediaArticle(Base, BaseMixin):
__tablename__ = 'media_article'
@@ -124,6 +157,17 @@ class MediaArticle(Base, BaseMixin):
self.title = import_data['title']
self.url = import_data['url']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['review'] = self.review
item['title'] = self.title
item['url'] = self.url
return item
class MediaVideo(Base, BaseMixin):
__tablename__ = 'media_video'
@@ -147,3 +191,18 @@ class MediaVideo(Base, BaseMixin):
self.title = import_data['title']
self.url = import_data['url']
self.should_download = import_data['should_download']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['cloud_link'] = self.cloud_link
item['file_name'] = self.file_name
item['path'] = self.path
item['review'] = self.review
item['title'] = self.title
item['url'] = self.url
item['should_download'] = self.should_download
return item
kontor-scripts/db/models/metadata.py
-62
View File
@@ -1,62 +0,0 @@
from typing import Any, AnyStr, Dict
from sqlalchemy import Column, String, ForeignKey, Integer, Boolean
from sqlalchemy.orm import relationship
from db.models.base import Base, BaseMixin
class MetaDataTable(Base, BaseMixin):
__tablename__ = 'meta_data_table'
table_name = Column(String, unique=True)
table_columns = relationship("MetaDataColumn")
def __repr__(self):
return f'MetaDataTable({self.id} {self.table_name})'
def __str__(self):
return f'{self.table_name}({self.id})'
def import_dict(self, import_data: Dict[AnyStr, Any]):
self.id = import_data['id']
self.created_date = import_data['created_date']
self.last_modified_date = import_data['last_modified_date']
self.version = import_data['version']
self.table_name = import_data['table_name']
class MetaDataColumn(Base, BaseMixin):
__tablename__ = 'meta_data_column'
column_name = Column(String, nullable=False)
column_type = Column(String)
column_order = Column(Integer)
is_shown = Column(Boolean)
column_label = Column(String)
show_filter = Column(Boolean)
filter_label = Column(String)
ref_column = Column(String, nullable=True)
table_id = Column(String, ForeignKey('meta_data_table.id'))
table = relationship("MetaDataTable", back_populates="table_columns")
def __repr__(self):
if self.column_name is None:
return f'MetaDataColumn({self.id} {self.table.table_name}.__)'
else:
return f'MetaDataColumn({self.id} {self.table.table_name}.{self.column_name})'
def __str__(self):
return f'{self.column_name}({self.id})'
def import_dict(self, import_data: Dict[AnyStr, Any]):
self.id = import_data['id']
self.created_date = import_data['created_date']
self.last_modified_date = import_data['last_modified_date']
self.version = import_data['version']
self.column_name = import_data['column_name']
self.column_type = import_data['column_type']
self.column_order = import_data['column_order']
self.table_id = import_data['table_id']
self.is_shown = import_data['is_shown']
self.column_label = import_data['column_label']
self.show_filter = import_data['show_filter']
self.filter_label = import_data['filter_label']
self.ref_column = import_data['ref_column']
kontor-scripts/db/models/tysc.py
+85
View File
@@ -24,6 +24,14 @@ class Sport(Base, BaseMixin):
self.version = import_data['version']
self.name = import_data['name']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
return item
class Team(Base, BaseMixin):
__tablename__ = "team"
@@ -42,6 +50,16 @@ class Team(Base, BaseMixin):
self.short_name = import_data['short_name']
self.sport_id = import_data['sport_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
item['short_name'] = self.short_name
item['sport_id'] = self.sport_id
return item
class FieldPosition(Base, BaseMixin):
__tablename__ = "field_position"
@@ -64,6 +82,17 @@ class FieldPosition(Base, BaseMixin):
self.short_name = import_data['short_name']
self.sport_id = import_data['sport_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
item['short_name'] = self.short_name
item['sport_id'] = self.sport_id
return item
class Player(Base, BaseMixin):
__tablename__ = "player"
@@ -85,6 +114,16 @@ class Player(Base, BaseMixin):
self.first_name = import_data['first_name']
self.last_name = import_data['last_name']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['first_name'] = self.first_name
item['last_name'] = self.last_name
return item
class Rooster(Base, BaseMixin):
__tablename__ = "rooster"
@@ -110,6 +149,18 @@ class Rooster(Base, BaseMixin):
self.player_id = import_data['player_id']
self.position_id = import_data['position_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['year'] = self.year
item['team_id'] = self.team_id
item['player_id'] = self.player_id
item['position_id'] = self.position_id
return item
class Vendor(Base, BaseMixin):
__tablename__ = "vendor"
@@ -124,6 +175,15 @@ class Vendor(Base, BaseMixin):
self.version = import_data['version']
self.name = import_data['name']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
return item
class CardSet(Base, BaseMixin):
__tablename__ = "card_set"
@@ -147,6 +207,18 @@ class CardSet(Base, BaseMixin):
self.insert_set = import_data['insert_set']
self.vendor_id = import_data['vendor_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['name'] = self.name
item['parallel_set'] = self.parallel_set
item['insert_set'] = self.insert_set
item['vendor_id'] = self.vendor_id
return item
class Card(Base, BaseMixin):
__tablename__ = "card"
@@ -172,3 +244,16 @@ class Card(Base, BaseMixin):
self.card_set_id = import_data['card_set_id']
self.rooster_id = import_data['rooster_id']
self.vendor_id = import_data['vendor_id']
def export_dict(self) -> Dict[AnyStr, Any]:
item: Dict[AnyStr, Any] = {}
item['id'] = self.id
item['created_date'] = str(self.created_date)
item['last_modified_date'] = str(self.last_modified_date)
item['version'] = self.version
item['card_number'] = self.card_number
item['year'] = self.year
item['card_set_id'] = self.card_set_id
item['rooster_id'] = self.rooster_id
item['vendor_id'] = self.vendor_id
return item
kontor-scripts/db/repository/metadata.py
-28
View File
@@ -1,28 +0,0 @@
from typing import List
from sqlalchemy.orm import Session
from db.models.metadata import MetaDataColumn, MetaDataTable
from db.schemas.metadata import MetaDataTableResponse, MetaDataColumnResponse
def get_tables(db: Session) -> List[MetaDataTableResponse]:
tables = db.query(MetaDataTable).all()
results: List[MetaDataTableResponse] = [MetaDataTableResponse(id=table.id, name=table.table_name) for table in tables]
return results
def get_columns_for_table(db: Session, table: MetaDataTableResponse)-> List[MetaDataColumnResponse]:
columns = db.query(MetaDataColumn).filter_by(table_id = table.id).all()
results: List[MetaDataColumnResponse] = []
for column in columns:
result: MetaDataColumnResponse = MetaDataColumnResponse(
id=str(column.id),
name=column.column_name,
label=column.column_label,
order=column.column_order,
ref_column=column.ref_column,
column_type=column.column_type)
results.append(result)
return results
kontor-scripts/db/schemas/metadata.py
-15
View File
@@ -1,15 +0,0 @@
from pydantic import BaseModel, PositiveInt
class MetaDataTableResponse(BaseModel):
id: str
name: str
class MetaDataColumnResponse(BaseModel):
id: str
name: str
label: str | None
order: PositiveInt
ref_column: str | None
column_type: str
kontor-scripts/export.py
+11 -20
View File
@@ -12,7 +12,6 @@ from pathlib import Path
from db.models import registry
from db.models.base import Base
from config import get_logger
from db.repository.metadata import get_tables, get_columns_for_table
parser = ArgumentParser(formatter_class=ArgumentDefaultsHelpFormatter)
parser.add_argument('--verbose', '-v', action='count', default=0)
@@ -40,31 +39,23 @@ if __name__ == '__main__':
__session__ = sessionmaker(bind=engine)
with __session__() as db:
data = {}
tables = get_tables(db)
tables = registry.keys()
for table in tables:
# logger.info(f"Table {table.name} with {table.id}")
columns = get_columns_for_table(db, table)
model = registry[table.name]
model = registry[table]
rows = db.query(model).all()
entries = []
for row in rows:
entry = {}
for column in columns:
# logger.info(f" Column {column.order} {column.name} with {column.id}")
try:
value = getattr(row, column.name)
if isinstance(value, datetime):
entry[column.name] = str(value)
else:
entry[column.name] = value
except AttributeError as error:
logger.info(f"{error}")
entry = row.export_dict()
entries.append(entry)
data[table.name] = entries
logger.info(f"{table.name}: {len(entries)} exported")
json_dump = json.dumps(data, indent=4)
with open(args.file, "w") as dump_file:
dump_file.write(json_dump)
data[table] = entries
logger.info(f"{table}: {len(entries)} exported")
try:
json_dump = json.dumps(data, indent=4)
with open(args.file, "w") as dump_file:
dump_file.write(json_dump)
except TypeError as error:
logger.info(f"{error}")
logger.info(f"{len(data)} tables exported")
#kontor_db = KontorDB(engine, logger)
#kontor_db.export_db(ExportType.JSON, args.file)
kontor-scripts/import.py
+9 -1
View File
@@ -3,6 +3,7 @@ import data from json file to PostgreSQL
"""
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
from datetime import datetime
from typing import Any, AnyStr, Dict, List
import os
import json
@@ -61,7 +62,14 @@ def get_ids(items: List[Any]) -> List[AnyStr]:
def update_item(db: Session, import_data: Dict[AnyStr, Any], item: Any, dry_run: bool, log):
for (key, value) in import_data.items():
existing_value = getattr(item, str(key))
if existing_value != value:
update: bool = False
if isinstance(existing_value, datetime):
if str(existing_value) != str(value):
update = True
else:
if existing_value != value:
update = True
if update:
if not dry_run:
log.debug(f"update {key}({existing_value}) with {value}")
setattr(item, str(key), value)
kontor-spring/src/main/java/de/thpeetz/kontor/admin/AdminConstants.java
-1
View File
@@ -49,7 +49,6 @@ public class AdminConstants {
data.addItem(new SideNavItem(MediaConstants.MEDIAACTORFILE, MediaActorFileView.class));
data.addItem(new SideNavItem(AUTHORIZATION, AssignmentView.class));
data.addItem(new SideNavItem("Data Import", ModuleDataView.class));
data.addItem(new SideNavItem("Meta Data", MetaDataView.class));
administration.addItem(data);
return administration;
}
kontor-spring/src/main/java/de/thpeetz/kontor/admin/SetupModuleAdmin.java
-319
View File
@@ -3,13 +3,10 @@ package de.thpeetz.kontor.admin;
import de.thpeetz.kontor.admin.data.Permission;
import de.thpeetz.kontor.admin.data.Profile;
import de.thpeetz.kontor.admin.data.Assignment;
import de.thpeetz.kontor.admin.data.MetaDataTable;
import de.thpeetz.kontor.admin.repository.AssignmentRepository;
import de.thpeetz.kontor.admin.repository.ProfileRepository;
import de.thpeetz.kontor.admin.repository.MailAccountRepository;
import de.thpeetz.kontor.admin.services.AdminService;
import de.thpeetz.kontor.admin.services.MetaDataService;
import de.thpeetz.kontor.mailclient.data.MailAccount;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -44,9 +41,6 @@ public class SetupModuleAdmin implements ApplicationListener<ContextRefreshedEve
@Autowired
private AdminService adminService;
@Autowired
private MetaDataService metaDataService;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
if (alreadySetup) {
@@ -64,8 +58,6 @@ public class SetupModuleAdmin implements ApplicationListener<ContextRefreshedEve
}
log.info("MailProperties: {}", mailProperties);
initMail(mailProperties);
initMetaData();
}
private void initMail(MailProperties mailProperties) {
@@ -131,315 +123,4 @@ public class SetupModuleAdmin implements ApplicationListener<ContextRefreshedEve
}
return admin;
}
private void initMetaData() {
log.info("initMetaData");
MetaDataTable mediaArticleTable = metaDataService.getTable("media_article");
metaDataService.getColumn(mediaArticleTable, "id", "TEXT", 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(mediaArticleTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "", Boolean.FALSE, null);
metaDataService.getColumn(mediaArticleTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "", Boolean.FALSE, null);
metaDataService.getColumn(mediaArticleTable, "version", "LONG", 4, Boolean.FALSE, "", Boolean.FALSE, null);
metaDataService.getColumn(mediaArticleTable, "url", "TEXT", 5, Boolean.TRUE, "URL", Boolean.FALSE, null);
metaDataService.getColumn(mediaArticleTable, "review", "BOOLEAN", 6, Boolean.TRUE, "Review", Boolean.TRUE, "Review");
metaDataService.getColumn(mediaArticleTable, "title", "TEXT", 7, Boolean.TRUE, "Title", Boolean.FALSE, null);
MetaDataTable mediaVideoTable = metaDataService.getTable("media_video");
metaDataService.getColumn(mediaVideoTable, "id", "TEXT", 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(mediaVideoTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "", Boolean.FALSE, null);
metaDataService.getColumn(mediaVideoTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "", Boolean.FALSE, null);
metaDataService.getColumn(mediaVideoTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(mediaVideoTable, "url", "TEXT", 5, Boolean.TRUE, "URL", Boolean.FALSE, null);
metaDataService.getColumn(mediaVideoTable, "review", "BOOLEAN", 6, Boolean.TRUE, "Review", Boolean.TRUE, "Review");
metaDataService.getColumn(mediaVideoTable, "should_download", "BOOLEAN", 7, Boolean.TRUE, "Download", Boolean.TRUE, "Download");
metaDataService.getColumn(mediaVideoTable, "title", "TEXT", 8, Boolean.TRUE, "Title", Boolean.FALSE, null);
metaDataService.getColumn(mediaVideoTable, "file_name", "TEXT", 9, Boolean.FALSE, "", Boolean.FALSE, null);
metaDataService.getColumn(mediaVideoTable, "path", "TEXT", 10, Boolean.FALSE, "", Boolean.FALSE, null);
metaDataService.getColumn(mediaVideoTable, "cloud_link", "TEXT", 11, Boolean.FALSE, "", Boolean.FALSE, null);
MetaDataTable mediaFileTable = metaDataService.getTable("media_file");
metaDataService.getColumn(mediaFileTable, "id", "TEXT", 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(mediaFileTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(mediaFileTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(mediaFileTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(mediaFileTable, "url", "TEXT" , 5, Boolean.TRUE, "URL", Boolean.FALSE, null);
metaDataService.getColumn(mediaFileTable, "review", "BOOLEAN" , 6, Boolean.TRUE, "Review", Boolean.TRUE, "Review");
metaDataService.getColumn(mediaFileTable, "should_download", "BOOLEAN" , 7, Boolean.TRUE, "Download", Boolean.TRUE, "Download");
metaDataService.getColumn(mediaFileTable, "title", "TEXT" , 8, Boolean.TRUE, "Title", Boolean.FALSE, null);
metaDataService.getColumn(mediaFileTable, "file_name", "TEXT" , 9, Boolean.TRUE, "Dateiname", Boolean.FALSE, null);
metaDataService.getColumn(mediaFileTable, "path", "TEXT" , 10, Boolean.TRUE, "Verzeichnis", Boolean.FALSE, null);
metaDataService.getColumn(mediaFileTable, "cloud_link", "TEXT" , 11, Boolean.TRUE, "Cloud Link", Boolean.FALSE, null);
MetaDataTable mediaActorTable = metaDataService.getTable("media_actor");
metaDataService.getColumn(mediaActorTable, "id", "TEXT" , 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(mediaActorTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(mediaActorTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(mediaActorTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(mediaActorTable, "name", "TEXT" , 5, Boolean.TRUE, "", Boolean.FALSE, null);
MetaDataTable mediaActorFileTable = metaDataService.getTable("media_actor_file");
metaDataService.getColumn(mediaActorFileTable, "id", "TEXT" , 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(mediaActorFileTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(mediaActorFileTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(mediaActorFileTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(mediaActorFileTable, "media_actor_id", "TEXT" , 5, Boolean.TRUE, "Actor", Boolean.FALSE, null, "name");
metaDataService.getColumn(mediaActorFileTable, "media_file_id", "TEXT" , 6, Boolean.TRUE, "File", Boolean.FALSE, null, "title");
MetaDataTable artistTable = metaDataService.getTable("artist");
metaDataService.getColumn(artistTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(artistTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(artistTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(artistTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(artistTable, "name", "TEXT" , 5, Boolean.FALSE, "Name", Boolean.FALSE, null);
metaDataService.getColumn(artistTable, "weblink", "TEXT" , 6, Boolean.TRUE, "Link", Boolean.FALSE, null);
MetaDataTable publisherTable = metaDataService.getTable("publisher");
metaDataService.getColumn(publisherTable, "id", "TEXT" , 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(publisherTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(publisherTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(publisherTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(publisherTable, "name", "TEXT" , 5, Boolean.TRUE, "Name", Boolean.FALSE, null);
metaDataService.getColumn(publisherTable, "weblink", "TEXT" , 6, Boolean.TRUE, "Link", Boolean.FALSE, null);
metaDataService.getColumn(publisherTable, "parent_publisher_id", "TEXT" , 7, Boolean.TRUE, "Parent Company", Boolean.FALSE, null, "name");
MetaDataTable comicTable = metaDataService.getTable("comic");
metaDataService.getColumn(comicTable, "id", "TEXT" , 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(comicTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(comicTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(comicTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(comicTable, "completed", "BOOLEAN" , 5, Boolean.TRUE, "Complete", Boolean.TRUE, "Complete");
metaDataService.getColumn(comicTable, "current_order", "BOOLEAN" , 6, Boolean.TRUE, "Bestellung", Boolean.TRUE, "Bestellung");
metaDataService.getColumn(comicTable, "title", "TEXT" , 7, Boolean.TRUE, "Title", Boolean.FALSE, null);
metaDataService.getColumn(comicTable, "publisher_id", "TEXT" , 8, Boolean.TRUE, "Verlag", Boolean.FALSE, null, "name");
metaDataService.getColumn(comicTable, "weblink", "TEXT" , 9, Boolean.TRUE, "Link", Boolean.FALSE, null);
MetaDataTable issueTable = metaDataService.getTable("issue");
metaDataService.getColumn(issueTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(issueTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(issueTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(issueTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(issueTable, "in_stock", "BOOLEAN" , 5, Boolean.FALSE, "Auf Lager", Boolean.FALSE, null);
metaDataService.getColumn(issueTable, "is_read", "BOOLEAN" , 6, Boolean.FALSE, "Gelesen", Boolean.FALSE, null);
metaDataService.getColumn(issueTable, "issue_number", "TEXT" , 7, Boolean.FALSE, "Heft", Boolean.FALSE, null);
metaDataService.getColumn(issueTable, "comic_id", "TEXT" , 8, Boolean.FALSE, "Comic", Boolean.FALSE, null, "title");
metaDataService.getColumn(issueTable, "volume_id", "TEXT" , 9, Boolean.FALSE, "Volume", Boolean.FALSE, null, "name");
metaDataService.getColumn(issueTable, "story_arc_id", "TEXT" , 10, Boolean.FALSE, "Story Arc", Boolean.FALSE, null, "name");
MetaDataTable volumeTable = metaDataService.getTable("volume");
metaDataService.getColumn(volumeTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(volumeTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(volumeTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(volumeTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(volumeTable, "name", "TEXT" , 5, Boolean.FALSE, "Name", Boolean.FALSE, null);
metaDataService.getColumn(volumeTable, "comic_id", "TEXT" , 6, Boolean.FALSE, "Comic", Boolean.FALSE, null, "title");
MetaDataTable tpbTable = metaDataService.getTable("trade_paperback");
metaDataService.getColumn(tpbTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(tpbTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(tpbTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(tpbTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(tpbTable, "issue_start", "LONG" , 5, Boolean.FALSE, "Anfang", Boolean.FALSE, null);
metaDataService.getColumn(tpbTable, "issue_end", "LONG" , 6, Boolean.FALSE, "Ende", Boolean.FALSE, null);
metaDataService.getColumn(tpbTable, "name", "TEXT" , 7, Boolean.FALSE, "Name", Boolean.FALSE, null);
metaDataService.getColumn(tpbTable, "comic_id", "TEXT" , 8, Boolean.FALSE, "Comic", Boolean.FALSE, null, "title");
MetaDataTable storyArcTable = metaDataService.getTable("story_arc");
metaDataService.getColumn(storyArcTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(storyArcTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(storyArcTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(storyArcTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(storyArcTable, "name", "TEXT" , 5, Boolean.FALSE, "Name", Boolean.FALSE, null);
metaDataService.getColumn(storyArcTable, "comic_id", "TEXT" , 6, Boolean.FALSE, "Comic", Boolean.FALSE, null, "title");
metaDataService.getColumn(storyArcTable, "volume_id", "TEXT" , 7, Boolean.FALSE, "Volume", Boolean.FALSE, null, "name");
MetaDataTable worktypeTable = metaDataService.getTable("worktype");
metaDataService.getColumn(worktypeTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(worktypeTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(worktypeTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(worktypeTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(worktypeTable, "name", "TEXT" , 5, Boolean.FALSE, "Name", Boolean.FALSE, null);
MetaDataTable comicworkTable = metaDataService.getTable("comic_work");
metaDataService.getColumn(comicworkTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(comicworkTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(comicworkTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(comicworkTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(comicworkTable, "artist_id", "TEXT" , 5, Boolean.FALSE, "Artist", Boolean.FALSE, null, "name");
metaDataService.getColumn(comicworkTable, "comic_id", "TEXT" , 6, Boolean.FALSE, "Comic", Boolean.FALSE, null, "title");
metaDataService.getColumn(comicworkTable, "work_type_id", "TEXT" , 7, Boolean.FALSE, "Arbeit", Boolean.FALSE, null, "name");
MetaDataTable authorTable = metaDataService.getTable("author");
metaDataService.getColumn(authorTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(authorTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(authorTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(authorTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(authorTable, "first_name", "TEXT" , 5, Boolean.FALSE, "Vorname", Boolean.FALSE, null);
metaDataService.getColumn(authorTable, "last_name", "TEXT" , 6, Boolean.FALSE, "Nachname", Boolean.FALSE, null);
MetaDataTable articleTable = metaDataService.getTable("article");
metaDataService.getColumn(articleTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(articleTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(articleTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(articleTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(articleTable, "title", "TEXT" , 5, Boolean.FALSE, "Titel", Boolean.FALSE, null);
MetaDataTable articleAuthorTable = metaDataService.getTable("article_author");
metaDataService.getColumn(articleAuthorTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(articleAuthorTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(articleAuthorTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(articleAuthorTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(articleAuthorTable, "article_id", "TEXT" , 5, Boolean.FALSE, "Artikel", Boolean.FALSE, null, "title");
metaDataService.getColumn(articleAuthorTable, "author_id", "TEXT" , 6, Boolean.FALSE, "Autor", Boolean.FALSE, null, "name");
MetaDataTable bookTable = metaDataService.getTable("book");
metaDataService.getColumn(bookTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(bookTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(bookTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(bookTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(bookTable, "isbn", "TEXT" , 5, Boolean.FALSE, "ISBN", Boolean.FALSE, null);
metaDataService.getColumn(bookTable, "title", "TEXT" , 6, Boolean.FALSE, "Titel", Boolean.FALSE, null);
metaDataService.getColumn(bookTable, "year", "LONG" , 7, Boolean.FALSE, "Jahr", Boolean.FALSE, null);
metaDataService.getColumn(bookTable, "publisher_id", "TEXT" , 8, Boolean.FALSE, "Verlag", Boolean.FALSE, null, "name");
MetaDataTable bookAuthorTable = metaDataService.getTable("book_author");
metaDataService.getColumn(bookAuthorTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(bookAuthorTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(bookAuthorTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(bookAuthorTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(bookAuthorTable, "author_id", "TEXT" , 5, Boolean.FALSE, "Autor", Boolean.FALSE, null, "name");
metaDataService.getColumn(bookAuthorTable, "book_id", "TEXT" , 6, Boolean.FALSE, "Buch", Boolean.FALSE, null, "title");
MetaDataTable bookshelfPublisherTable = metaDataService.getTable("bookshelf_publisher");
metaDataService.getColumn(bookshelfPublisherTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(bookshelfPublisherTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(bookshelfPublisherTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(bookshelfPublisherTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(bookshelfPublisherTable, "name", "TEXT" , 5, Boolean.FALSE, "Name", Boolean.FALSE, null);
MetaDataTable sportTable = metaDataService.getTable("sport");
metaDataService.getColumn(sportTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(sportTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(sportTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(sportTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(sportTable, "name", "TEXT" , 5, Boolean.FALSE, "Name", Boolean.FALSE, null);
MetaDataTable playerTable = metaDataService.getTable("player");
metaDataService.getColumn(playerTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(playerTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(playerTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(playerTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(playerTable, "first_name", "TEXT" , 5, Boolean.FALSE, "Vorname", Boolean.FALSE, null);
metaDataService.getColumn(playerTable, "last_name", "TEXT" , 6, Boolean.FALSE, "Nachname", Boolean.FALSE, null);
MetaDataTable teamTable = metaDataService.getTable("team");
metaDataService.getColumn(teamTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(teamTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(teamTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(teamTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(teamTable, "name", "TEXT" , 5, Boolean.FALSE, "Name", Boolean.FALSE, null);
metaDataService.getColumn(teamTable, "short_name", "TEXT" , 6, Boolean.FALSE, "Kurzname", Boolean.FALSE, null);
metaDataService.getColumn(teamTable, "sport_id", "TEXT" , 7, Boolean.FALSE, "Sport", Boolean.FALSE, null, "name");
MetaDataTable vendorTable = metaDataService.getTable("vendor");
metaDataService.getColumn(vendorTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(vendorTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(vendorTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(vendorTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(vendorTable, "name", "TEXT" , 5, Boolean.FALSE, "Name", Boolean.FALSE, null);
MetaDataTable fieldPositionTable = metaDataService.getTable("field_position");
metaDataService.getColumn(fieldPositionTable, "id", "TEXT" , 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(fieldPositionTable, "created_date", "TIMESTAMP" , 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(fieldPositionTable, "last_modified_date", "TIMESTAMP" , 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(fieldPositionTable, "version", "LONG" , 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(fieldPositionTable, "name", "TEXT" , 5, Boolean.FALSE, "Name", Boolean.FALSE, null);
metaDataService.getColumn(fieldPositionTable, "short_name", "TEXT" , 6, Boolean.FALSE, "Kurzname", Boolean.FALSE, null);
metaDataService.getColumn(fieldPositionTable, "sport_id", "TEXT" , 7, Boolean.FALSE, "Sport", Boolean.FALSE, null, "name");
MetaDataTable roosterTable = metaDataService.getTable("rooster");
metaDataService.getColumn(roosterTable, "id", "TEXT", 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(roosterTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(roosterTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(roosterTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(roosterTable, "year", "LONG", 5, Boolean.FALSE, "Jahr", Boolean.FALSE, null);
metaDataService.getColumn(roosterTable, "player_id", "TEXT", 6, Boolean.FALSE, "Spieler", Boolean.FALSE, null, "last_name");
metaDataService.getColumn(roosterTable, "position_id", "TEXT", 7, Boolean.FALSE, "Position", Boolean.FALSE, null, "short_name");
metaDataService.getColumn(roosterTable, "team_id", "TEXT", 8, Boolean.FALSE, "Team", Boolean.FALSE, null, "name");
MetaDataTable cardSetTable = metaDataService.getTable("card_set");
metaDataService.getColumn(cardSetTable, "id", "TEXT", 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(cardSetTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(cardSetTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(cardSetTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(cardSetTable, "insert_set", "BOOLEAN", 5, Boolean.FALSE, "Insertset?", Boolean.FALSE, null);
metaDataService.getColumn(cardSetTable, "parallel_set", "BOOLEAN", 6, Boolean.FALSE, "Parallelset?", Boolean.FALSE, null);
metaDataService.getColumn(cardSetTable, "name", "TEXT", 7, Boolean.FALSE, "Name", Boolean.FALSE, null);
metaDataService.getColumn(cardSetTable, "vendor_id", "TEXT", 8, Boolean.FALSE, "Hersteller", Boolean.FALSE, null, "name");
MetaDataTable cardTable = metaDataService.getTable("card");
metaDataService.getColumn(cardTable, "id", "TEXT", 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(cardTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(cardTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(cardTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(cardTable, "card_number", "LONG", 5, Boolean.FALSE, "Nummmer", Boolean.FALSE, null);
metaDataService.getColumn(cardTable, "year", "LONG", 6, Boolean.FALSE, "Jahr", Boolean.FALSE, null);
metaDataService.getColumn(cardTable, "card_set_id", "TEXT", 7, Boolean.FALSE, "Set", Boolean.FALSE, null, "name");
metaDataService.getColumn(cardTable, "rooster_id", "TEXT", 8, Boolean.FALSE, "Spieler", Boolean.FALSE, null, "name");
metaDataService.getColumn(cardTable, "vendor_id", "TEXT", 9, Boolean.FALSE, "Hersteller", Boolean.FALSE, null, "name");
MetaDataTable profileTable = metaDataService.getTable("profile");
metaDataService.getColumn(profileTable, "id", "TEXT", 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(profileTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(profileTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(profileTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(profileTable, "first_name", "TEXT", 5, Boolean.TRUE, "Vorname", Boolean.FALSE, null);
metaDataService.getColumn(profileTable, "last_name", "TEXT", 6, Boolean.TRUE, "Nachname", Boolean.FALSE, null);
metaDataService.getColumn(profileTable, "user_name", "TEXT", 7, Boolean.TRUE, "Login", Boolean.FALSE, null);
metaDataService.getColumn(profileTable, "email", "TEXT", 8, Boolean.TRUE, "Email", Boolean.FALSE, null);
metaDataService.getColumn(profileTable, "password", "TEXT", 9, Boolean.FALSE, "Password", Boolean.FALSE, null);
metaDataService.getColumn(profileTable, "enabled", "BOOLEAN", 10, Boolean.TRUE, "Aktiv?", Boolean.TRUE, null);
MetaDataTable tokenTable = metaDataService.getTable("token");
metaDataService.getColumn(tokenTable, "id", "TEXT"
, 1, Boolean.TRUE, "", Boolean.FALSE, null);
metaDataService.getColumn(tokenTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(tokenTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(tokenTable, "version", "LONG", 4, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(tokenTable, "token", "TEXT", 5, Boolean.TRUE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(tokenTable, "name", "TEXT", 6, Boolean.TRUE, "Name", Boolean.FALSE, null);
metaDataService.getColumn(tokenTable, "last_used_date", "TIMESTAMP", 7, Boolean.FALSE, "Verwendet", Boolean.FALSE, null);
metaDataService.getColumn(tokenTable, "enabled", "BOOLEAN", 8, Boolean.TRUE, "Aktiv", Boolean.TRUE, "Enabled");
metaDataService.getColumn(tokenTable, "profile_id", "TEXT", 9, Boolean.TRUE, "Profile", Boolean.FALSE, null, "user_name");
MetaDataTable permissionTable = metaDataService.getTable("permission");
metaDataService.getColumn(permissionTable, "id", "TEXT", 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(permissionTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(permissionTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(permissionTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(permissionTable, "name", "TEXT", 5, Boolean.TRUE, "Name", Boolean.FALSE, null);
MetaDataTable AssignmentTable = metaDataService.getTable("assignment");
metaDataService.getColumn(AssignmentTable, "id", "TEXT", 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(AssignmentTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(AssignmentTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(AssignmentTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(AssignmentTable, "profile_id", "TEXT", 5, Boolean.TRUE, "Profile", Boolean.FALSE, null, "user_name");
metaDataService.getColumn(AssignmentTable, "permission_id", "TEXT", 6, Boolean.TRUE, "Permission", Boolean.FALSE, null, "name");
MetaDataTable moduleDataTable = metaDataService.getTable("module_data");
metaDataService.getColumn(moduleDataTable, "id", "TEXT", 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(moduleDataTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(moduleDataTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(moduleDataTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(moduleDataTable, "module_name", "TEXT", 5, Boolean.TRUE, "Module", Boolean.FALSE, null);
metaDataService.getColumn(moduleDataTable, "import_data", "BOOLEAN", 6, Boolean.TRUE, "Import Data?", Boolean.TRUE, "Import Data");
MetaDataTable mailAccountTable = metaDataService.getTable("mail_account");
metaDataService.getColumn(mailAccountTable, "id", "TEXT", 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(mailAccountTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(mailAccountTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(mailAccountTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(mailAccountTable, "host", "TEXT", 5, Boolean.TRUE, "Host", Boolean.FALSE, null);
metaDataService.getColumn(mailAccountTable, "port", "LONG", 6, Boolean.TRUE, "Port", Boolean.FALSE, null);
metaDataService.getColumn(mailAccountTable, "protocol", "TEXT", 7, Boolean.TRUE, "Protocol", Boolean.FALSE, null);
metaDataService.getColumn(mailAccountTable, "user_name", "TEXT", 8, Boolean.TRUE, "Username", Boolean.FALSE, null);
metaDataService.getColumn(mailAccountTable, "password", "TEXT", 9, Boolean.FALSE, "Password", Boolean.FALSE, null);
metaDataService.getColumn(mailAccountTable, "start_tls", "BOOLEAN", 10, Boolean.TRUE, "StartTLS", Boolean.TRUE, "StartTLS");
MetaDataTable mailTable = metaDataService.getTable("mail");
metaDataService.getColumn(mailTable, "id", "TEXT", 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(mailTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(mailTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(mailTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(mailTable, "folder", "TEXT", 5, Boolean.TRUE, "Folder", Boolean.FALSE, null);
metaDataService.getColumn(mailTable, "subject", "TEXT", 6, Boolean.TRUE, "Subject", Boolean.FALSE, null);
metaDataService.getColumn(mailTable, "body", "TEXT", 7, Boolean.FALSE, "Body", Boolean.FALSE, null);
metaDataService.getColumn(mailTable, "sent_date", "TIMESTAMP", 8, Boolean.FALSE, "Gesendet", Boolean.FALSE, null);
metaDataService.getColumn(mailTable, "received_date", "TIMESTAMP", 9, Boolean.FALSE, "Empfangen", Boolean.FALSE, null);
MetaDataTable metaDataTableTable = metaDataService.getTable("meta_data_table");
metaDataService.getColumn(metaDataTableTable, "id", "TEXT", 1, Boolean.TRUE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(metaDataTableTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(metaDataTableTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(metaDataTableTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(metaDataTableTable, "table_name", "TEXT", 5, Boolean.TRUE, "Table", Boolean.FALSE, null);
MetaDataTable metaDataColumnTable = metaDataService.getTable("meta_data_column");
metaDataService.getColumn(metaDataColumnTable, "id", "TEXT", 1, Boolean.FALSE, "ID", Boolean.FALSE, null);
metaDataService.getColumn(metaDataColumnTable, "created_date", "TIMESTAMP", 2, Boolean.FALSE, "Created", Boolean.FALSE, null);
metaDataService.getColumn(metaDataColumnTable, "last_modified_date", "TIMESTAMP", 3, Boolean.FALSE, "Modified", Boolean.FALSE, null);
metaDataService.getColumn(metaDataColumnTable, "version", "LONG", 4, Boolean.FALSE, "Version", Boolean.FALSE, null);
metaDataService.getColumn(metaDataColumnTable, "column_name", "TEXT", 5, Boolean.TRUE, "Column", Boolean.FALSE, null);
metaDataService.getColumn(metaDataColumnTable, "column_type", "TEXT", 7, Boolean.TRUE, "Type", Boolean.FALSE, null);
metaDataService.getColumn(metaDataColumnTable, "column_order", "LONG", 9, Boolean.TRUE, "Order", Boolean.FALSE, null);
metaDataService.getColumn(metaDataColumnTable, "is_shown", "BOOLEAN", 10, Boolean.TRUE, "Is Shown", Boolean.TRUE, "Is Shown");
metaDataService.getColumn(metaDataColumnTable, "column_label", "TEXT", 11, Boolean.TRUE, "Label", Boolean.FALSE, null);
metaDataService.getColumn(metaDataColumnTable, "show_filter", "BOOLEAN", 12, Boolean.TRUE, "Show Filter", Boolean.TRUE, "Show Filter");
metaDataService.getColumn(metaDataColumnTable, "filter_label", "TEXT", 13, Boolean.TRUE, "Filter Label", Boolean.FALSE, null);
metaDataService.getColumn(metaDataColumnTable, "ref_column", "TEXT", 14, Boolean.TRUE, "Ref Column", Boolean.FALSE, null);
metaDataService.getColumn(metaDataColumnTable, "table_id", "TEXT", 15, Boolean.TRUE, "Table", Boolean.FALSE, null, "table_name");
}
}
kontor-spring/src/main/java/de/thpeetz/kontor/admin/data/MetaDataColumn.java
-61
View File
@@ -1,61 +0,0 @@
package de.thpeetz.kontor.admin.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.annotation.Nullable;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Entity
@Getter
@Setter
@Table(
indexes = @Index(columnList = "columnName, table_id"),
uniqueConstraints = @UniqueConstraint(columnNames = {"table_id", "columnOrder"})
)
public class MetaDataColumn extends AbstractEntity {
@NotNull
private String columnName;
private String columnType;
private Integer columnOrder;
private Boolean isShown;
private String columnLabel;
private Boolean showFilter = Boolean.FALSE;
private String filterLabel;
@Nullable
private String refColumn;
@ManyToOne
@JoinColumn(name = "table_id")
@NotNull
private MetaDataTable table;
public String getTableName() {
return table.getTableName();
}
public String updateColumnName(String value) {
if (!this.getColumnName().equals(value)) {
this.setColumnName(value);
log.info("update columnName");
return "updated " + this.getId() + " with " + value + "\n";
}
return "no changes for " + this.getId() + "\n";
}
@Override
public String toString() {
return "MetaDataColumn{id=" + getId() + ", columnName=" + columnName + ", table=" + table.getTableName() +'}';
}
}
kontor-spring/src/main/java/de/thpeetz/kontor/admin/data/MetaDataTable.java
-40
View File
@@ -1,40 +0,0 @@
package de.thpeetz.kontor.admin.data;
import de.thpeetz.kontor.common.data.AbstractEntity;
import jakarta.persistence.*;
import jakarta.validation.constraints.NotNull;
import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
@Slf4j
@Entity
@Getter
@Setter
@Table(
indexes = @Index(columnList = "tableName"),
uniqueConstraints = @UniqueConstraint(columnNames = {"tableName"})
)
public class MetaDataTable extends AbstractEntity {
@NotNull
private String tableName;
@OneToMany(fetch = FetchType.EAGER, mappedBy = "table")
private List<MetaDataColumn> tableColumns = new LinkedList<>();
public String updateTableName(String value) {
if (!this.getTableName().equals(value)) {
this.setTableName(value);
log.info("update tableName");
return "updated " + this.getId() + " with " + value;
}
return "no changes for " + this.getId();
}
}
kontor-spring/src/main/java/de/thpeetz/kontor/admin/repository/MetaDataColumnRepository.java
-20
View File
@@ -1,20 +0,0 @@
package de.thpeetz.kontor.admin.repository;
import de.thpeetz.kontor.admin.data.MetaDataColumn;
import de.thpeetz.kontor.admin.data.MetaDataTable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import java.util.List;
public interface MetaDataColumnRepository extends JpaRepository<MetaDataColumn, String> {
List<MetaDataColumn> findByTable(MetaDataTable table);
List<MetaDataColumn> findByTableAndColumnName(MetaDataTable table, String column_name);
@Query("select m from MetaDataColumn m " +
"where lower(m.columnName) like lower(concat('%', :searchTerm, '%')) or lower(m.columnLabel) like lower(concat('%', :searchTerm, '%'))")
List<MetaDataColumn> search(@Param("searchTerm") String searchTerm);
}
kontor-spring/src/main/java/de/thpeetz/kontor/admin/repository/MetaDataTableRepository.java
-9
View File
@@ -1,9 +0,0 @@
package de.thpeetz.kontor.admin.repository;
import de.thpeetz.kontor.admin.data.MetaDataTable;
import org.springframework.data.jpa.repository.JpaRepository;
public interface MetaDataTableRepository extends JpaRepository<MetaDataTable, String> {
MetaDataTable findByTableName(String tableName);
}
kontor-spring/src/main/java/de/thpeetz/kontor/admin/services/MetaDataService.java
-245
View File
@@ -1,245 +0,0 @@
package de.thpeetz.kontor.admin.services;
import org.springframework.stereotype.Service;
import de.thpeetz.kontor.admin.data.MetaDataColumn;
import de.thpeetz.kontor.admin.repository.MetaDataColumnRepository;
import de.thpeetz.kontor.admin.data.MetaDataTable;
import de.thpeetz.kontor.admin.repository.MetaDataTableRepository;
import lombok.extern.slf4j.Slf4j;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicReference;
@Slf4j
@Service
public class MetaDataService {
private final MetaDataTableRepository metaDataTableRepository;
private final MetaDataColumnRepository metaDataColumnRepository;
public MetaDataService(MetaDataTableRepository metaDataTableRepository, MetaDataColumnRepository metaDataColumnRepository) {
this.metaDataTableRepository = metaDataTableRepository;
this.metaDataColumnRepository = metaDataColumnRepository;
}
public List<MetaDataTable> findAllTables() {
return metaDataTableRepository.findAll();
}
public MetaDataTable getTable(String tableName) {
MetaDataTable table = metaDataTableRepository.findByTableName(tableName);
if (table == null) {
log.info("Metadata for table {} not found, will create it", tableName);
table = new MetaDataTable();
table.setTableName(tableName);
metaDataTableRepository.save(table);
}
return table;
}
private void deleteTable(MetaDataTable metaDataTable) {
List<MetaDataColumn> columns = metaDataTable.getTableColumns();
List<MetaDataColumn> columnsToDelete = new LinkedList<>();
for (MetaDataColumn column: columns) {
try {
columnsToDelete.add(column);
metaDataColumnRepository.delete(column);
} catch (Exception e) {
log.info("Exception {} thrown, just go on", e.getMessage());
}
}
for (MetaDataColumn column: columnsToDelete) {
metaDataTable.getTableColumns().remove(column);
}
try {
metaDataTableRepository.delete(metaDataTable);
} catch (Exception e) {
log.info("could not delete MetaDataTable: {}", e.getMessage());
}
}
public void getColumn(MetaDataTable table, String columnName, String columnType, Integer columnOrder, Boolean isShown, String columnLabel, Boolean showFilter, String filterLabel) {
this.getColumn(table, columnName, columnType, columnOrder, isShown, columnLabel, showFilter, filterLabel, null);
}
public void checkColumnValues(MetaDataTable table, MetaDataColumn column, String columnName, String columnType, Integer columnOrder, Boolean isShown, String columnLabel, Boolean showFilter, String filterLabel, String refColumn) {
log.debug("Column {} with name {} of table {} found, check Values", columnOrder, columnName, table.getTableName());
if (!column.getColumnName().equals(columnName)) {
log.debug("columnName has to be changed to {}", columnName);
column.setColumnName(columnName);
}
if (!column.getColumnType().equals(columnType)) {
log.debug("columnType has to be changed to {}", columnType);
column.setColumnType(columnType);
}
if (isShown != null && !isShown.equals(column.getIsShown())) {
log.debug("isShown has to be change to {}}", isShown);
column.setIsShown(isShown);
}
if (columnLabel != null && !columnLabel.equals(column.getColumnLabel())) {
log.debug("columnLabel has to be change to {}}", columnLabel);
column.setColumnLabel(columnLabel);
}
if (showFilter != null &&!showFilter.equals(column.getShowFilter())) {
log.debug("showFilter has to be change to {}}", showFilter);
column.setShowFilter(showFilter);
}
if (filterLabel != null && !filterLabel.equals(column.getFilterLabel())) {
log.debug("filterLabel has to be change to {}}", filterLabel);
column.setFilterLabel(filterLabel);
}
if (refColumn != null && !refColumn.equals(column.getRefColumn())) {
log.debug("refColumn has to be change to {}}", filterLabel);
column.setRefColumn(refColumn);
}
saveMetaDataColumn(column);
}
public void getColumn(MetaDataTable table, String columnName, String columnType, Integer columnOrder, Boolean isShown, String columnLabel, Boolean showFilter, String filterLabel, String refColumn) {
log.info("check if column {} of table {} exists", columnName, table.getTableName());
boolean columnNameExists = table.getTableColumns().stream().anyMatch(column -> column.getColumnName().equals(columnName));
boolean columnOrderExists = false;
if (table.getTableColumns().size() > columnOrder-1) {
columnOrderExists = table.getTableColumns().get(columnOrder-1) != null;
}
List<MetaDataColumn> metaDataColumns = metaDataColumnRepository.findByTableAndColumnName(table, columnName);
log.debug("column found: name: {}, order: {}: table.columns: {}", columnNameExists, columnOrderExists, metaDataColumns);
if (columnOrderExists) {
MetaDataColumn column = table.getTableColumns().get(columnOrder-1);
checkColumnValues(table, column, columnName, columnType, columnOrder, isShown, columnLabel, showFilter, filterLabel, refColumn);
} else {
log.info("Column {} of table {} not found, will create it", columnName, table.getTableName());
addColumn(table, columnName, columnType, columnOrder, isShown, refColumn);
}
}
private void addColumn(MetaDataTable table, String columnName, String columnType, Integer columnOrder, Boolean isShown, String refColumn) {
MetaDataColumn column = new MetaDataColumn();
column.setTable(table);
column.setColumnName(columnName);
column.setColumnType(columnType);
column.setColumnOrder(columnOrder);
column.setIsShown(isShown);
column.setRefColumn(refColumn);
saveMetaDataColumn(column);
}
public List<MetaDataColumn> findAllMetaDataColumns(String stringFilter) {
if (stringFilter == null || stringFilter.isEmpty()) {
log.debug("Found " + metaDataColumnRepository.count()+ " entries");
return metaDataColumnRepository.findAll();
} else {
List<MetaDataColumn> results = metaDataColumnRepository.search(stringFilter);
log.debug("Found " + results.size() + " entries");
return results;
}
}
public void deleteMetaDataColumn(MetaDataColumn metaDataColumn) {
if (metaDataColumn == null) {
log.warn("MetaDataColumn is null, can't delete it");
return;
}
log.debug("deleteMetaDataColumn: MetaDataColumn={}", metaDataColumn);
metaDataColumnRepository.delete(metaDataColumn);
}
public void saveMetaDataColumn(MetaDataColumn metaDataColumn) {
if (metaDataColumn == null) {
log.warn("MetaDataColumn is null, can't save it");
return;
}
log.debug("saveMetaDataColumn: MetaDataColumn={}", metaDataColumn);
metaDataColumnRepository.save(metaDataColumn);
}
public String importTableData(Map<String, String> fields) {
AtomicReference<String> status = new AtomicReference<>("unknown");
String id = fields.get("id");
Optional<MetaDataTable> optional = metaDataTableRepository.findById(id);
if (optional.isEmpty()) {
log.info(" not found: {} with {}", id, fields);
status.set(id + "not found");
MetaDataTable checkExisting = metaDataTableRepository.findByTableName(fields.get("table_name"));
if (checkExisting != null) {
log.info("entry already there with different id ({}), will be deleted", checkExisting.getId());
deleteTable(checkExisting);
}
MetaDataTable metaDataTable = new MetaDataTable();
metaDataTable.setId(id);
metaDataTable.setTableName(fields.get("table_name"));
metaDataTableRepository.save(metaDataTable);
} else {
optional.ifPresent( entry -> {
log.info(" found: {}", entry.getTableName());
String updateStatus = updateTableFields(entry, fields);
metaDataTableRepository.save(entry);
status.set(updateStatus);
});
}
return status.get();
}
public String importColumnData(String tableName, Map<String, String> fields) {
AtomicReference<String> status = new AtomicReference<>("unknown");
String id = fields.get("id");
Optional<MetaDataColumn> optional = metaDataColumnRepository.findById(id);
if (optional.isEmpty()) {
log.info(" not found: {} with {}", id, fields);
status.set(id + "not found");
MetaDataColumn metaDataColumn = new MetaDataColumn();
metaDataColumn.setId(id);
metaDataColumn.setColumnName(fields.get("column_name"));
metaDataColumn.setColumnType(fields.get("column_type"));
metaDataColumnRepository.save(metaDataColumn);
} else {
optional.ifPresent( entry -> {
log.info(" found: {}", entry.getTableName());
String updateStatus = updateColumnFields(entry, tableName, fields);
metaDataColumnRepository.save(entry);
status.set(updateStatus);
});
}
return status.get();
}
private String updateColumnFields(MetaDataColumn metaDataColumn, String tableName, Map<String, String> fields) {
StringBuilder status = new StringBuilder();
for (Map.Entry<String, String> entry : fields.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
switch (key) {
case "id", "created_date", "last_modified_date", "version":
break;
case "column_name":
status.append(metaDataColumn.updateColumnName(value));
break;
default:
log.info("field {} is unknown for table {}", key, tableName);
}
}
return status.toString();
}
private String updateTableFields(MetaDataTable metaDataTable, Map<String, String> fields) {
String status = "";
for (Map.Entry<String, String> entry : fields.entrySet()) {
String key = entry.getKey();
String value = entry.getValue();
switch (key) {
case "id", "created_date", "last_modified_date", "version":
break;
case "table_name":
status += metaDataTable.updateTableName(value);
default:
log.info("field {} is unknown for table {}", key, MetaDataTable.class.getName());
}
}
return status;
}
}
kontor-spring/src/main/java/de/thpeetz/kontor/admin/views/MetaDataForm.java
-120
View File
@@ -1,120 +0,0 @@
package de.thpeetz.kontor.admin.views;
import com.vaadin.flow.component.ComponentEvent;
import com.vaadin.flow.component.ComponentEventListener;
import com.vaadin.flow.component.Key;
import com.vaadin.flow.component.button.Button;
import com.vaadin.flow.component.button.ButtonVariant;
import com.vaadin.flow.component.checkbox.Checkbox;
import com.vaadin.flow.component.combobox.ComboBox;
import com.vaadin.flow.component.formlayout.FormLayout;
import com.vaadin.flow.component.orderedlayout.HorizontalLayout;
import com.vaadin.flow.component.textfield.IntegerField;
import com.vaadin.flow.component.textfield.TextField;
import com.vaadin.flow.data.binder.BeanValidationBinder;
import com.vaadin.flow.data.binder.Binder;
import de.thpeetz.kontor.admin.data.MetaDataColumn;
import de.thpeetz.kontor.admin.data.MetaDataTable;
import lombok.*;
import java.util.List;
public class MetaDataForm extends FormLayout {
ComboBox<MetaDataTable> table = new ComboBox<>("Table");
TextField columnName = new TextField("Column Name");
IntegerField columnOrder = new IntegerField("Column Order");
Checkbox isShown = new Checkbox("Is Shown");
TextField columnLabel = new TextField("Column Label");
Checkbox showFilter = new Checkbox("Show Filter");
TextField filterLabel = new TextField("Filter Label");
TextField refColumn = new TextField("Ref Column");
Button save = new com.vaadin.flow.component.button.Button("Save");
Button delete = new com.vaadin.flow.component.button.Button("Delete");
Button close = new Button("Cancel");
Binder<MetaDataColumn> binder = new BeanValidationBinder<>(MetaDataColumn.class);
public MetaDataForm(List<MetaDataTable> tables) {
addClassName("metaData-form");
binder.bindInstanceFields(this);
table.setItems(tables);
table.setItemLabelGenerator(MetaDataTable::getTableName);
add(table, columnName, columnOrder);
add(isShown, columnLabel);
isShown.addClickListener(click -> columnLabel.setEnabled(isShown.getValue()));
add(showFilter, filterLabel);
showFilter.addClickListener(click -> filterLabel.setEnabled(showFilter.getValue()));
add(refColumn);
add(createButtonsLayout());
}
private HorizontalLayout createButtonsLayout() {
save.addThemeVariants(ButtonVariant.LUMO_PRIMARY);
delete.addThemeVariants(ButtonVariant.LUMO_ERROR);
close.addThemeVariants(ButtonVariant.LUMO_TERTIARY);
save.addClickShortcut(Key.ENTER);
close.addClickShortcut(Key.ESCAPE);
save.addClickListener(event -> validateAndSave());
delete.addClickListener(event -> fireEvent(new MetaDataForm.DeleteEvent(this, binder.getBean())));
close.addClickListener(event -> fireEvent(new MetaDataForm.CloseEvent(this)));
binder.addStatusChangeListener(e -> save.setEnabled(binder.isValid()));
return new HorizontalLayout(save, delete, close);
}
private void validateAndSave() {
if (binder.isValid()) {
fireEvent(new MetaDataForm.SaveEvent(this, binder.getBean()));
}
}
public void setMetaDataColumn(MetaDataColumn metaDataColumn) {
binder.setBean(metaDataColumn);
}
@Getter
public abstract static class MetaDataFormEvent extends ComponentEvent<MetaDataForm> {
private final MetaDataColumn metaDataColumn;
protected MetaDataFormEvent(MetaDataForm source, MetaDataColumn metaDataColumn) {
super(source, false);
this.metaDataColumn = metaDataColumn;
}
}
public static class SaveEvent extends MetaDataForm.MetaDataFormEvent {
SaveEvent(MetaDataForm source, MetaDataColumn metaDataColumn) {
super(source, metaDataColumn);
}
}
public static class DeleteEvent extends MetaDataForm.MetaDataFormEvent {
DeleteEvent(MetaDataForm source, MetaDataColumn metaDataColumn) {
super(source, metaDataColumn);
}
}
public static class CloseEvent extends MetaDataForm.MetaDataFormEvent {
CloseEvent(MetaDataForm source) {
super(source, null);
}
}
public void addDeleteListener(ComponentEventListener<MetaDataForm.DeleteEvent> listener) {
addListener(MetaDataForm.DeleteEvent.class, listener);
}
public void addSaveListener(ComponentEventListener<MetaDataForm.SaveEvent> listener) {
addListener(MetaDataForm.SaveEvent.class, listener);
}
public void addCloseListener(ComponentEventListener<MetaDataForm.CloseEvent> listener) {
addListener(MetaDataForm.CloseEvent.class, listener);
}
}
kontor-spring/src/main/java/de/thpeetz/kontor/admin/views/MetaDataView.java
-185
View File
@@ -1,185 +0,0 @@
package de.thpeetz.kontor.admin.views;
import com.vaadin.flow.component.Component;
import com.vaadin.flow.component.button.Button;
import com.vaadin.flow.component.button.ButtonVariant;
import com.vaadin.flow.component.grid.Grid;
import com.vaadin.flow.component.grid.GridSortOrder;
import com.vaadin.flow.component.icon.Icon;
import com.vaadin.flow.component.icon.VaadinIcon;
import com.vaadin.flow.component.orderedlayout.HorizontalLayout;
import com.vaadin.flow.component.orderedlayout.VerticalLayout;
import com.vaadin.flow.component.textfield.TextField;
import com.vaadin.flow.data.provider.SortDirection;
import com.vaadin.flow.data.value.ValueChangeMode;
import com.vaadin.flow.router.PageTitle;
import com.vaadin.flow.router.Route;
import com.vaadin.flow.spring.annotation.SpringComponent;
import de.thpeetz.kontor.admin.AdminConstants;
import de.thpeetz.kontor.admin.data.MetaDataColumn;
import de.thpeetz.kontor.admin.services.MetaDataService;
import de.thpeetz.kontor.common.views.MainLayout;
import de.thpeetz.kontor.common.views.ColumnToggleContextMenu;
import de.thpeetz.kontor.common.views.StatusIcon;
import jakarta.annotation.security.RolesAllowed;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Scope;
import java.util.ArrayList;
import java.util.List;
@Slf4j
@SpringComponent
@Scope("prototype")
@RolesAllowed("ROLE_ADMIN")
@Route(value = AdminConstants.METADATA_ROUTE, layout = MainLayout.class)
@PageTitle("Meta Data | Admin | Kontor")
public class MetaDataView extends VerticalLayout {
Grid<MetaDataColumn> grid = new Grid<>(MetaDataColumn.class, false);
Grid.Column<MetaDataColumn> idColumn = grid.addColumn(MetaDataColumn::getId)
.setHeader("ID").setResizable(true).setSortable(true);
Grid.Column<MetaDataColumn> createdColumn = grid.addColumn(MetaDataColumn::getCreatedDate)
.setHeader("Erstellt").setResizable(true).setSortable(true);
Grid.Column<MetaDataColumn> modifiedColumn = grid.addColumn(MetaDataColumn::getLastModifiedDate)
.setHeader("Geändert").setResizable(true).setSortable(true);
Grid.Column<MetaDataColumn> versionColumn = grid.addColumn(MetaDataColumn::getVersion)
.setHeader("Version").setResizable(true).setSortable(true);
Grid.Column<MetaDataColumn> tableColumn = grid.addColumn(MetaDataColumn::getTableName)
.setHeader("Table").setResizable(true).setSortable(true);
Grid.Column<MetaDataColumn> columnNameColumn = grid.addColumn(MetaDataColumn::getColumnName)
.setHeader("Column Name").setResizable(true).setSortable(true);
Grid.Column<MetaDataColumn> columnTypeColumn = grid.addColumn(MetaDataColumn::getColumnType)
.setHeader("Column Type").setResizable(true).setSortable(true);
Grid.Column<MetaDataColumn> columnOrderColumn = grid.addColumn(MetaDataColumn::getColumnOrder)
.setHeader("Column Order").setResizable(true).setSortable(true);
Grid.Column<MetaDataColumn> isShownColumn = grid.addComponentColumn(metaDataColumn -> StatusIcon.create(metaDataColumn.getIsShown())).
setHeader("Anzeige?").setWidth("6rem").setSortable(true);
Grid.Column<MetaDataColumn> columnLabelColumn = grid.addColumn(MetaDataColumn::getColumnLabel)
.setHeader("Spaltenname").setResizable(true).setSortable(true);
Grid.Column<MetaDataColumn> showFilterColumn = grid.addComponentColumn(metaDataColumn -> StatusIcon.create(metaDataColumn.getShowFilter())).
setHeader("Zeige Filter").setWidth("6rem").setSortable(true);
Grid.Column<MetaDataColumn> filterLabelColumn = grid.addColumn(MetaDataColumn::getFilterLabel)
.setHeader("Filter Name").setResizable(true).setSortable(true);
Grid.Column<MetaDataColumn> refColumnColumn = grid.addColumn(MetaDataColumn::getRefColumn)
.setHeader("Ref Column Name").setResizable(true).setSortable(true);
TextField searchField = new TextField();
@Getter
MetaDataForm form;
MetaDataService service;
public MetaDataView(MetaDataService service) {
this.service = service;
addClassName("metadata-view");
setSizeFull();
configureGrid();
configureForm();
add(getToolbar(), getContent());
updateList();
}
private void configureGrid() {
grid.addClassName("metadata-grid");
grid.setSizeFull();
grid.getColumns().forEach(col -> col.setAutoWidth(true));
idColumn.setVisible(false);
createdColumn.setVisible(false);
modifiedColumn.setVisible(false);
versionColumn.setVisible(false);
grid.setMultiSort(true);
List<GridSortOrder<MetaDataColumn>> sortOrder = new ArrayList<>();
sortOrder.add(new GridSortOrder<MetaDataColumn>(tableColumn, SortDirection.ASCENDING));
sortOrder.add(new GridSortOrder<MetaDataColumn>(columnOrderColumn, SortDirection.ASCENDING));
grid.sort(sortOrder);
grid.asSingleSelect().addValueChangeListener(event -> editMetaData(event.getValue()));
}
private void configureForm() {
form = new MetaDataForm(service.findAllTables());
form.setWidth("25em");
form.setVisible(false);
form.addSaveListener(this::saveMetaData);
form.addDeleteListener(this::deleteMetaData);
form.addCloseListener(e -> closeEditor());
}
private Component getContent() {
HorizontalLayout content = new HorizontalLayout(grid, form);
content.setFlexGrow(2, grid);
content.setFlexGrow(1, form);
content.addClassName("content");
content.setSizeFull();
return content;
}
private HorizontalLayout getToolbar() {
searchField.setPlaceholder("Search");
searchField.setClearButtonVisible(true);
searchField.setPrefixComponent(new Icon(VaadinIcon.SEARCH));
searchField.setValueChangeMode(ValueChangeMode.EAGER);
searchField.addValueChangeListener(e -> updateList());
Button addMetaDataButton = new Button("Add Meta Data");
addMetaDataButton.addClickListener(click -> addMetaDataColumn());
Button menuButton = new Button("Show/Hide Columns");
menuButton.addThemeVariants(ButtonVariant.LUMO_TERTIARY);
ColumnToggleContextMenu<MetaDataColumn> columnToggleContextMenu = new ColumnToggleContextMenu<>(menuButton);
columnToggleContextMenu.addColumnToggleItem(idColumn);
columnToggleContextMenu.addColumnToggleItem(createdColumn);
columnToggleContextMenu.addColumnToggleItem(modifiedColumn);
columnToggleContextMenu.addColumnToggleItem(versionColumn);
columnToggleContextMenu.addColumnToggleItem(tableColumn);
columnToggleContextMenu.addColumnToggleItem(columnNameColumn);
columnToggleContextMenu.addColumnToggleItem(columnTypeColumn);
columnToggleContextMenu.addColumnToggleItem(columnOrderColumn);
columnToggleContextMenu.addColumnToggleItem(isShownColumn);
columnToggleContextMenu.addColumnToggleItem(columnLabelColumn);
columnToggleContextMenu.addColumnToggleItem(showFilterColumn);
columnToggleContextMenu.addColumnToggleItem(filterLabelColumn);
columnToggleContextMenu.addColumnToggleItem(refColumnColumn);
HorizontalLayout toolbar = new HorizontalLayout(searchField, addMetaDataButton, menuButton);
toolbar.addClassName("toolbar");
return toolbar;
}
private void saveMetaData(MetaDataForm.SaveEvent event) {
MetaDataColumn metaDataColumn = event.getMetaDataColumn();
service.saveMetaDataColumn(metaDataColumn);
updateList();
closeEditor();
}
private void deleteMetaData(MetaDataForm.DeleteEvent event) {
service.deleteMetaDataColumn(event.getMetaDataColumn());
updateList();
closeEditor();
}
public void editMetaData(MetaDataColumn metaDataColumn) {
if (metaDataColumn == null) {
closeEditor();
} else {
form.setMetaDataColumn(metaDataColumn);
form.setVisible(true);
addClassName("editing");
}
}
public void closeEditor() {
form.setMetaDataColumn(null);
form.setVisible(false);
removeClassName("editing");
}
private void addMetaDataColumn() {
grid.asSingleSelect().clear();
editMetaData(new MetaDataColumn());
}
private void updateList() {
grid.setItems(service.findAllMetaDataColumns(searchField.getValue()));
}
}
kontor-spring/src/main/java/de/thpeetz/kontor/data/services/DataManagementService.java
-13
View File
@@ -1,24 +1,17 @@
package de.thpeetz.kontor.data.services;
import de.thpeetz.kontor.admin.data.MetaDataTable;
import de.thpeetz.kontor.admin.repository.MetaDataTableRepository;
import de.thpeetz.kontor.admin.services.MetaDataService;
import de.thpeetz.kontor.tysc.services.SportService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.atomic.AtomicReference;
@Slf4j
@Service
public class DataManagementService {
@Autowired
MetaDataService metaDataService;
@Autowired
SportService sportService;
@@ -29,12 +22,6 @@ public class DataManagementService {
public String getEntry(String nodeName, Map<String, String> fields) {
AtomicReference<String> status = new AtomicReference<>("unknown");
switch (nodeName) {
case "meta_data_table":
status.set(metaDataService.importTableData(fields));
break;
case "meta_data_column":
status.set(metaDataService.importColumnData(nodeName, fields));
break;
case "sport":
status.set(sportService.importData(fields));
default: