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
committed by Thomas Peetz
parent c4705a2d5e
commit e0396eb5a9
20 changed files with 43 additions and 953 deletions
Download Patch File Download Diff File Expand all files Collapse all files
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/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/webapps/comic/route_comics.py
-6
View File
@@ -1,6 +1,5 @@
from fastapi import APIRouter, Form, Request, status
from fastapi.templating import Jinja2Templates
from fastapi.responses import RedirectResponse
from src.apis.utils import SessionDep
from src.db.models.comic import Comic, Publisher, Issue
@@ -10,11 +9,6 @@ from src.db.repository.comics.comic import update_comic
from src.schema.comics.comic import ComicSchema
from src.webapps.comic.forms.comic import ValidateComicForm
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=True, prefix="/comic")
kontor-scripts/db/models/admin.py
+10
View File
@@ -143,6 +143,16 @@ class Assignment(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"
kontor-scripts/db/models/comic.py
+24
View File
@@ -243,6 +243,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"
@@ -280,6 +294,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"
kontor-scripts/db/models/media.py
+9
View File
@@ -116,6 +116,15 @@ class MediaActor(Base, BaseMixin):
item['name'] = self.name
return item
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'
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/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-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
-242
View File
@@ -1,242 +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 = 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()));
}
}