🎉 Refactor utils directory: Remove unused files & add new script_collection.py 🎨📚
This commit is contained in:
@ -1,968 +0,0 @@
|
||||
"""
|
||||
Erweitertes Tabellen-System für das MYP-System
|
||||
=============================================
|
||||
|
||||
Dieses Modul stellt erweiterte Tabellen-Funktionalität bereit:
|
||||
- Sortierung nach allen Spalten
|
||||
- Erweiterte Filter-Optionen
|
||||
- Pagination mit anpassbaren Seitengrößen
|
||||
- Spalten-Auswahl und -anpassung
|
||||
- Export-Funktionen
|
||||
- Responsive Design
|
||||
"""
|
||||
|
||||
import re
|
||||
import json
|
||||
import math
|
||||
from datetime import datetime, timedelta
|
||||
from typing import Dict, List, Any, Optional, Tuple, Union, Callable
|
||||
from dataclasses import dataclass, asdict
|
||||
from enum import Enum
|
||||
from flask import request, jsonify
|
||||
from sqlalchemy import func, text, or_, and_
|
||||
from sqlalchemy.orm import Query
|
||||
|
||||
from utils.logging_config import get_logger
|
||||
from models import Job, User, Printer, GuestRequest, get_db_session
|
||||
|
||||
logger = get_logger("advanced_tables")
|
||||
|
||||
class SortDirection(Enum):
|
||||
ASC = "asc"
|
||||
DESC = "desc"
|
||||
|
||||
class FilterOperator(Enum):
|
||||
EQUALS = "eq"
|
||||
NOT_EQUALS = "ne"
|
||||
CONTAINS = "contains"
|
||||
NOT_CONTAINS = "not_contains"
|
||||
STARTS_WITH = "starts_with"
|
||||
ENDS_WITH = "ends_with"
|
||||
GREATER_THAN = "gt"
|
||||
LESS_THAN = "lt"
|
||||
GREATER_EQUAL = "gte"
|
||||
LESS_EQUAL = "lte"
|
||||
BETWEEN = "between"
|
||||
IN = "in"
|
||||
NOT_IN = "not_in"
|
||||
IS_NULL = "is_null"
|
||||
IS_NOT_NULL = "is_not_null"
|
||||
|
||||
@dataclass
|
||||
class SortConfig:
|
||||
"""Sortierung-Konfiguration"""
|
||||
column: str
|
||||
direction: SortDirection = SortDirection.ASC
|
||||
|
||||
@dataclass
|
||||
class FilterConfig:
|
||||
"""Filter-Konfiguration"""
|
||||
column: str
|
||||
operator: FilterOperator
|
||||
value: Any = None
|
||||
values: List[Any] = None
|
||||
|
||||
@dataclass
|
||||
class PaginationConfig:
|
||||
"""Pagination-Konfiguration"""
|
||||
page: int = 1
|
||||
page_size: int = 25
|
||||
max_page_size: int = 100
|
||||
|
||||
@dataclass
|
||||
class ColumnConfig:
|
||||
"""Spalten-Konfiguration"""
|
||||
key: str
|
||||
label: str
|
||||
sortable: bool = True
|
||||
filterable: bool = True
|
||||
searchable: bool = True
|
||||
visible: bool = True
|
||||
width: Optional[str] = None
|
||||
align: str = "left" # left, center, right
|
||||
format_type: str = "text" # text, number, date, datetime, boolean, currency
|
||||
format_options: Dict[str, Any] = None
|
||||
|
||||
@dataclass
|
||||
class TableConfig:
|
||||
"""Gesamt-Tabellen-Konfiguration"""
|
||||
table_id: str
|
||||
columns: List[ColumnConfig]
|
||||
default_sort: List[SortConfig] = None
|
||||
default_filters: List[FilterConfig] = None
|
||||
pagination: PaginationConfig = None
|
||||
searchable: bool = True
|
||||
exportable: bool = True
|
||||
selectable: bool = False
|
||||
row_actions: List[Dict[str, Any]] = None
|
||||
|
||||
class AdvancedTableQuery:
|
||||
"""Builder für erweiterte Tabellen-Abfragen"""
|
||||
|
||||
def __init__(self, base_query: Query, model_class):
|
||||
self.base_query = base_query
|
||||
self.model_class = model_class
|
||||
self.filters = []
|
||||
self.sorts = []
|
||||
self.search_term = None
|
||||
self.search_columns = []
|
||||
|
||||
def add_filter(self, filter_config: FilterConfig):
|
||||
"""Fügt einen Filter hinzu"""
|
||||
self.filters.append(filter_config)
|
||||
return self
|
||||
|
||||
def add_sort(self, sort_config: SortConfig):
|
||||
"""Fügt eine Sortierung hinzu"""
|
||||
self.sorts.append(sort_config)
|
||||
return self
|
||||
|
||||
def set_search(self, term: str, columns: List[str]):
|
||||
"""Setzt globale Suche"""
|
||||
self.search_term = term
|
||||
self.search_columns = columns
|
||||
return self
|
||||
|
||||
def build_query(self) -> Query:
|
||||
"""Erstellt die finale Query"""
|
||||
query = self.base_query
|
||||
|
||||
# Filter anwenden
|
||||
for filter_config in self.filters:
|
||||
query = self._apply_filter(query, filter_config)
|
||||
|
||||
# Globale Suche anwenden
|
||||
if self.search_term and self.search_columns:
|
||||
query = self._apply_search(query)
|
||||
|
||||
# Sortierung anwenden
|
||||
for sort_config in self.sorts:
|
||||
query = self._apply_sort(query, sort_config)
|
||||
|
||||
return query
|
||||
|
||||
def _apply_filter(self, query: Query, filter_config: FilterConfig) -> Query:
|
||||
"""Wendet einen Filter auf die Query an"""
|
||||
column = getattr(self.model_class, filter_config.column, None)
|
||||
if not column:
|
||||
logger.warning(f"Spalte {filter_config.column} nicht gefunden in {self.model_class}")
|
||||
return query
|
||||
|
||||
op = filter_config.operator
|
||||
value = filter_config.value
|
||||
values = filter_config.values
|
||||
|
||||
if op == FilterOperator.EQUALS:
|
||||
return query.filter(column == value)
|
||||
elif op == FilterOperator.NOT_EQUALS:
|
||||
return query.filter(column != value)
|
||||
elif op == FilterOperator.CONTAINS:
|
||||
return query.filter(column.ilike(f"%{value}%"))
|
||||
elif op == FilterOperator.NOT_CONTAINS:
|
||||
return query.filter(~column.ilike(f"%{value}%"))
|
||||
elif op == FilterOperator.STARTS_WITH:
|
||||
return query.filter(column.ilike(f"{value}%"))
|
||||
elif op == FilterOperator.ENDS_WITH:
|
||||
return query.filter(column.ilike(f"%{value}"))
|
||||
elif op == FilterOperator.GREATER_THAN:
|
||||
return query.filter(column > value)
|
||||
elif op == FilterOperator.LESS_THAN:
|
||||
return query.filter(column < value)
|
||||
elif op == FilterOperator.GREATER_EQUAL:
|
||||
return query.filter(column >= value)
|
||||
elif op == FilterOperator.LESS_EQUAL:
|
||||
return query.filter(column <= value)
|
||||
elif op == FilterOperator.BETWEEN and values and len(values) >= 2:
|
||||
return query.filter(column.between(values[0], values[1]))
|
||||
elif op == FilterOperator.IN and values:
|
||||
return query.filter(column.in_(values))
|
||||
elif op == FilterOperator.NOT_IN and values:
|
||||
return query.filter(~column.in_(values))
|
||||
elif op == FilterOperator.IS_NULL:
|
||||
return query.filter(column.is_(None))
|
||||
elif op == FilterOperator.IS_NOT_NULL:
|
||||
return query.filter(column.isnot(None))
|
||||
|
||||
return query
|
||||
|
||||
def _apply_search(self, query: Query) -> Query:
|
||||
"""Wendet globale Suche an"""
|
||||
if not self.search_term or not self.search_columns:
|
||||
return query
|
||||
|
||||
search_conditions = []
|
||||
for column_name in self.search_columns:
|
||||
column = getattr(self.model_class, column_name, None)
|
||||
if column:
|
||||
# Konvertiere zu String für Suche in numerischen Spalten
|
||||
search_conditions.append(
|
||||
func.cast(column, sqlalchemy.String).ilike(f"%{self.search_term}%")
|
||||
)
|
||||
|
||||
if search_conditions:
|
||||
return query.filter(or_(*search_conditions))
|
||||
|
||||
return query
|
||||
|
||||
def _apply_sort(self, query: Query, sort_config: SortConfig) -> Query:
|
||||
"""Wendet Sortierung an"""
|
||||
column = getattr(self.model_class, sort_config.column, None)
|
||||
if not column:
|
||||
logger.warning(f"Spalte {sort_config.column} für Sortierung nicht gefunden")
|
||||
return query
|
||||
|
||||
if sort_config.direction == SortDirection.DESC:
|
||||
return query.order_by(column.desc())
|
||||
else:
|
||||
return query.order_by(column.asc())
|
||||
|
||||
class TableDataProcessor:
|
||||
"""Verarbeitet Tabellendaten für die Ausgabe"""
|
||||
|
||||
def __init__(self, config: TableConfig):
|
||||
self.config = config
|
||||
|
||||
def process_data(self, data: List[Any]) -> List[Dict[str, Any]]:
|
||||
"""Verarbeitet rohe Daten für Tabellen-Ausgabe"""
|
||||
processed_rows = []
|
||||
|
||||
for item in data:
|
||||
row = {}
|
||||
for column in self.config.columns:
|
||||
if not column.visible:
|
||||
continue
|
||||
|
||||
# Wert extrahieren
|
||||
value = self._extract_value(item, column.key)
|
||||
|
||||
# Formatieren
|
||||
formatted_value = self._format_value(value, column)
|
||||
|
||||
row[column.key] = {
|
||||
'raw': value,
|
||||
'formatted': formatted_value,
|
||||
'sortable': column.sortable,
|
||||
'filterable': column.filterable
|
||||
}
|
||||
|
||||
# Row Actions hinzufügen
|
||||
if self.config.row_actions:
|
||||
row['_actions'] = self._get_row_actions(item)
|
||||
|
||||
# Row Metadata
|
||||
row['_id'] = getattr(item, 'id', None)
|
||||
row['_type'] = item.__class__.__name__.lower()
|
||||
|
||||
processed_rows.append(row)
|
||||
|
||||
return processed_rows
|
||||
|
||||
def _extract_value(self, item: Any, key: str) -> Any:
|
||||
"""Extrahiert Wert aus einem Objekt"""
|
||||
try:
|
||||
# Unterstützung für verschachtelte Attribute (z.B. "user.name")
|
||||
if '.' in key:
|
||||
obj = item
|
||||
for part in key.split('.'):
|
||||
obj = getattr(obj, part, None)
|
||||
if obj is None:
|
||||
break
|
||||
return obj
|
||||
else:
|
||||
return getattr(item, key, None)
|
||||
except AttributeError:
|
||||
return None
|
||||
|
||||
def _format_value(self, value: Any, column: ColumnConfig) -> str:
|
||||
"""Formatiert einen Wert basierend auf dem Spaltentyp"""
|
||||
if value is None:
|
||||
return ""
|
||||
|
||||
format_type = column.format_type
|
||||
options = column.format_options or {}
|
||||
|
||||
if format_type == "date" and isinstance(value, datetime):
|
||||
date_format = options.get('format', '%d.%m.%Y')
|
||||
return value.strftime(date_format)
|
||||
|
||||
elif format_type == "datetime" and isinstance(value, datetime):
|
||||
datetime_format = options.get('format', '%d.%m.%Y %H:%M')
|
||||
return value.strftime(datetime_format)
|
||||
|
||||
elif format_type == "number" and isinstance(value, (int, float)):
|
||||
decimals = options.get('decimals', 0)
|
||||
return f"{value:.{decimals}f}"
|
||||
|
||||
elif format_type == "currency" and isinstance(value, (int, float)):
|
||||
currency = options.get('currency', '€')
|
||||
decimals = options.get('decimals', 2)
|
||||
return f"{value:.{decimals}f} {currency}"
|
||||
|
||||
elif format_type == "boolean":
|
||||
true_text = options.get('true_text', 'Ja')
|
||||
false_text = options.get('false_text', 'Nein')
|
||||
return true_text if value else false_text
|
||||
|
||||
elif format_type == "truncate":
|
||||
max_length = options.get('max_length', 50)
|
||||
text = str(value)
|
||||
if len(text) > max_length:
|
||||
return text[:max_length-3] + "..."
|
||||
return text
|
||||
|
||||
return str(value)
|
||||
|
||||
def _get_row_actions(self, item: Any) -> List[Dict[str, Any]]:
|
||||
"""Generiert verfügbare Aktionen für eine Zeile"""
|
||||
actions = []
|
||||
|
||||
for action_config in self.config.row_actions:
|
||||
# Prüfe Bedingungen für Aktion
|
||||
if self._check_action_condition(item, action_config):
|
||||
actions.append({
|
||||
'type': action_config['type'],
|
||||
'label': action_config['label'],
|
||||
'icon': action_config.get('icon'),
|
||||
'url': self._build_action_url(item, action_config),
|
||||
'method': action_config.get('method', 'GET'),
|
||||
'confirm': action_config.get('confirm'),
|
||||
'class': action_config.get('class', '')
|
||||
})
|
||||
|
||||
return actions
|
||||
|
||||
def _check_action_condition(self, item: Any, action_config: Dict[str, Any]) -> bool:
|
||||
"""Prüft ob eine Aktion für ein Item verfügbar ist"""
|
||||
condition = action_config.get('condition')
|
||||
if not condition:
|
||||
return True
|
||||
|
||||
try:
|
||||
# Einfache Bedingungsprüfung
|
||||
if isinstance(condition, dict):
|
||||
for key, expected_value in condition.items():
|
||||
actual_value = self._extract_value(item, key)
|
||||
if actual_value != expected_value:
|
||||
return False
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
def _build_action_url(self, item: Any, action_config: Dict[str, Any]) -> str:
|
||||
"""Erstellt URL für eine Aktion"""
|
||||
url_template = action_config.get('url', '')
|
||||
|
||||
# Ersetze Platzhalter in URL
|
||||
try:
|
||||
return url_template.format(id=getattr(item, 'id', ''))
|
||||
except Exception:
|
||||
return url_template
|
||||
|
||||
def parse_table_request(request_data: Dict[str, Any]) -> Tuple[List[SortConfig], List[FilterConfig], PaginationConfig, str]:
|
||||
"""Parst Tabellen-Request-Parameter"""
|
||||
|
||||
# Sortierung parsen
|
||||
sorts = []
|
||||
sort_data = request_data.get('sort', [])
|
||||
if isinstance(sort_data, dict):
|
||||
sort_data = [sort_data]
|
||||
|
||||
for sort_item in sort_data:
|
||||
if isinstance(sort_item, dict):
|
||||
column = sort_item.get('column')
|
||||
direction = SortDirection(sort_item.get('direction', 'asc'))
|
||||
if column:
|
||||
sorts.append(SortConfig(column=column, direction=direction))
|
||||
|
||||
# Filter parsen
|
||||
filters = []
|
||||
filter_data = request_data.get('filters', [])
|
||||
if isinstance(filter_data, dict):
|
||||
filter_data = [filter_data]
|
||||
|
||||
for filter_item in filter_data:
|
||||
if isinstance(filter_item, dict):
|
||||
column = filter_item.get('column')
|
||||
operator = FilterOperator(filter_item.get('operator', 'eq'))
|
||||
value = filter_item.get('value')
|
||||
values = filter_item.get('values')
|
||||
|
||||
if column:
|
||||
filters.append(FilterConfig(
|
||||
column=column,
|
||||
operator=operator,
|
||||
value=value,
|
||||
values=values
|
||||
))
|
||||
|
||||
# Pagination parsen
|
||||
page = int(request_data.get('page', 1))
|
||||
page_size = min(int(request_data.get('page_size', 25)), 100)
|
||||
pagination = PaginationConfig(page=page, page_size=page_size)
|
||||
|
||||
# Suche parsen
|
||||
search = request_data.get('search', '')
|
||||
|
||||
return sorts, filters, pagination, search
|
||||
|
||||
def get_advanced_table_javascript() -> str:
|
||||
"""JavaScript für erweiterte Tabellen"""
|
||||
return """
|
||||
class AdvancedTable {
|
||||
constructor(tableId, config = {}) {
|
||||
this.tableId = tableId;
|
||||
this.config = {
|
||||
apiUrl: '/api/table-data',
|
||||
pageSize: 25,
|
||||
searchDelay: 500,
|
||||
sortable: true,
|
||||
filterable: true,
|
||||
searchable: true,
|
||||
...config
|
||||
};
|
||||
|
||||
this.currentSort = [];
|
||||
this.currentFilters = [];
|
||||
this.currentPage = 1;
|
||||
this.currentSearch = '';
|
||||
this.totalPages = 1;
|
||||
this.totalItems = 0;
|
||||
|
||||
this.searchTimeout = null;
|
||||
|
||||
this.init();
|
||||
}
|
||||
|
||||
init() {
|
||||
this.setupTable();
|
||||
this.setupEventListeners();
|
||||
this.loadData();
|
||||
}
|
||||
|
||||
setupTable() {
|
||||
const table = document.getElementById(this.tableId);
|
||||
if (!table) return;
|
||||
|
||||
table.classList.add('advanced-table');
|
||||
|
||||
// Add table wrapper
|
||||
const wrapper = document.createElement('div');
|
||||
wrapper.className = 'table-wrapper';
|
||||
table.parentNode.insertBefore(wrapper, table);
|
||||
wrapper.appendChild(table);
|
||||
|
||||
// Add controls
|
||||
this.createControls(wrapper);
|
||||
}
|
||||
|
||||
createControls(wrapper) {
|
||||
const controls = document.createElement('div');
|
||||
controls.className = 'table-controls';
|
||||
controls.innerHTML = `
|
||||
<div class="table-controls-left">
|
||||
<div class="search-box">
|
||||
<input type="text" id="${this.tableId}-search" placeholder="Suchen..." class="search-input">
|
||||
<span class="search-icon">🔍</span>
|
||||
</div>
|
||||
<div class="page-size-selector">
|
||||
<label>Einträge pro Seite:</label>
|
||||
<select id="${this.tableId}-page-size">
|
||||
<option value="10">10</option>
|
||||
<option value="25" selected>25</option>
|
||||
<option value="50">50</option>
|
||||
<option value="100">100</option>
|
||||
</select>
|
||||
</div>
|
||||
</div>
|
||||
<div class="table-controls-right">
|
||||
<button class="btn-filter" id="${this.tableId}-filter-btn">Filter</button>
|
||||
<button class="btn-export" id="${this.tableId}-export-btn">Export</button>
|
||||
<button class="btn-refresh" id="${this.tableId}-refresh-btn">↻</button>
|
||||
</div>
|
||||
`;
|
||||
|
||||
wrapper.insertBefore(controls, wrapper.firstChild);
|
||||
|
||||
// Add pagination
|
||||
const pagination = document.createElement('div');
|
||||
pagination.className = 'table-pagination';
|
||||
pagination.id = `${this.tableId}-pagination`;
|
||||
wrapper.appendChild(pagination);
|
||||
}
|
||||
|
||||
setupEventListeners() {
|
||||
// Search
|
||||
const searchInput = document.getElementById(`${this.tableId}-search`);
|
||||
searchInput?.addEventListener('input', (e) => {
|
||||
clearTimeout(this.searchTimeout);
|
||||
this.searchTimeout = setTimeout(() => {
|
||||
this.currentSearch = e.target.value;
|
||||
this.currentPage = 1;
|
||||
this.loadData();
|
||||
}, this.config.searchDelay);
|
||||
});
|
||||
|
||||
// Page size
|
||||
const pageSizeSelect = document.getElementById(`${this.tableId}-page-size`);
|
||||
pageSizeSelect?.addEventListener('change', (e) => {
|
||||
this.config.pageSize = parseInt(e.target.value);
|
||||
this.currentPage = 1;
|
||||
this.loadData();
|
||||
});
|
||||
|
||||
// Refresh
|
||||
const refreshBtn = document.getElementById(`${this.tableId}-refresh-btn`);
|
||||
refreshBtn?.addEventListener('click', () => {
|
||||
this.loadData();
|
||||
});
|
||||
|
||||
// Export
|
||||
const exportBtn = document.getElementById(`${this.tableId}-export-btn`);
|
||||
exportBtn?.addEventListener('click', () => {
|
||||
this.exportData();
|
||||
});
|
||||
|
||||
// Table header clicks (sorting)
|
||||
const table = document.getElementById(this.tableId);
|
||||
table?.addEventListener('click', (e) => {
|
||||
const th = e.target.closest('th[data-sortable="true"]');
|
||||
if (th) {
|
||||
const column = th.dataset.column;
|
||||
this.toggleSort(column);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
toggleSort(column) {
|
||||
const existingSort = this.currentSort.find(s => s.column === column);
|
||||
|
||||
if (existingSort) {
|
||||
if (existingSort.direction === 'asc') {
|
||||
existingSort.direction = 'desc';
|
||||
} else {
|
||||
// Remove sort
|
||||
this.currentSort = this.currentSort.filter(s => s.column !== column);
|
||||
}
|
||||
} else {
|
||||
this.currentSort.push({ column, direction: 'asc' });
|
||||
}
|
||||
|
||||
this.updateSortHeaders();
|
||||
this.loadData();
|
||||
}
|
||||
|
||||
updateSortHeaders() {
|
||||
const table = document.getElementById(this.tableId);
|
||||
const headers = table?.querySelectorAll('th[data-column]');
|
||||
|
||||
headers?.forEach(th => {
|
||||
const column = th.dataset.column;
|
||||
const sort = this.currentSort.find(s => s.column === column);
|
||||
|
||||
th.classList.remove('sort-asc', 'sort-desc');
|
||||
|
||||
if (sort) {
|
||||
th.classList.add(`sort-${sort.direction}`);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
async loadData() {
|
||||
try {
|
||||
const params = {
|
||||
page: this.currentPage,
|
||||
page_size: this.config.pageSize,
|
||||
search: this.currentSearch,
|
||||
sort: this.currentSort,
|
||||
filters: this.currentFilters
|
||||
};
|
||||
|
||||
const response = await fetch(this.config.apiUrl, {
|
||||
method: 'POST',
|
||||
headers: {
|
||||
'Content-Type': 'application/json',
|
||||
},
|
||||
body: JSON.stringify(params)
|
||||
});
|
||||
|
||||
const data = await response.json();
|
||||
|
||||
if (data.success) {
|
||||
this.renderTable(data.data);
|
||||
this.updatePagination(data.pagination);
|
||||
} else {
|
||||
console.error('Table data loading failed:', data.error);
|
||||
}
|
||||
|
||||
} catch (error) {
|
||||
console.error('Table data loading error:', error);
|
||||
}
|
||||
}
|
||||
|
||||
renderTable(data) {
|
||||
const table = document.getElementById(this.tableId);
|
||||
const tbody = table?.querySelector('tbody');
|
||||
|
||||
if (!tbody) return;
|
||||
|
||||
tbody.innerHTML = '';
|
||||
|
||||
data.forEach(row => {
|
||||
const tr = document.createElement('tr');
|
||||
tr.dataset.id = row._id;
|
||||
|
||||
// Render cells
|
||||
Object.keys(row).forEach(key => {
|
||||
if (key.startsWith('_')) return; // Skip metadata
|
||||
|
||||
const td = document.createElement('td');
|
||||
const cellData = row[key];
|
||||
|
||||
if (typeof cellData === 'object' && cellData.formatted !== undefined) {
|
||||
td.innerHTML = cellData.formatted;
|
||||
td.dataset.raw = cellData.raw;
|
||||
} else {
|
||||
td.textContent = cellData;
|
||||
}
|
||||
|
||||
tr.appendChild(td);
|
||||
});
|
||||
|
||||
// Add actions column if exists
|
||||
if (row._actions && row._actions.length > 0) {
|
||||
const actionsTd = document.createElement('td');
|
||||
actionsTd.className = 'actions-cell';
|
||||
actionsTd.innerHTML = this.renderActions(row._actions);
|
||||
tr.appendChild(actionsTd);
|
||||
}
|
||||
|
||||
tbody.appendChild(tr);
|
||||
});
|
||||
}
|
||||
|
||||
renderActions(actions) {
|
||||
return actions.map(action => {
|
||||
const confirmAttr = action.confirm ? `onclick="return confirm('${action.confirm}')"` : '';
|
||||
const icon = action.icon ? `<span class="action-icon">${action.icon}</span>` : '';
|
||||
|
||||
return `<a href="${action.url}" class="action-btn ${action.class}" ${confirmAttr}>
|
||||
${icon}${action.label}
|
||||
</a>`;
|
||||
}).join(' ');
|
||||
}
|
||||
|
||||
updatePagination(pagination) {
|
||||
this.currentPage = pagination.page;
|
||||
this.totalPages = pagination.total_pages;
|
||||
this.totalItems = pagination.total_items;
|
||||
|
||||
const paginationEl = document.getElementById(`${this.tableId}-pagination`);
|
||||
if (!paginationEl) return;
|
||||
|
||||
paginationEl.innerHTML = `
|
||||
<div class="pagination-info">
|
||||
Zeige ${pagination.start_item}-${pagination.end_item} von ${pagination.total_items} Einträgen
|
||||
</div>
|
||||
<div class="pagination-controls">
|
||||
${this.renderPaginationButtons()}
|
||||
</div>
|
||||
`;
|
||||
|
||||
// Event listeners für Pagination
|
||||
paginationEl.querySelectorAll('.page-btn').forEach(btn => {
|
||||
btn.addEventListener('click', (e) => {
|
||||
e.preventDefault();
|
||||
const page = parseInt(btn.dataset.page);
|
||||
if (page !== this.currentPage) {
|
||||
this.currentPage = page;
|
||||
this.loadData();
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
renderPaginationButtons() {
|
||||
const buttons = [];
|
||||
const maxButtons = 7;
|
||||
|
||||
// Previous button
|
||||
buttons.push(`
|
||||
<button class="page-btn ${this.currentPage === 1 ? 'disabled' : ''}"
|
||||
data-page="${this.currentPage - 1}" ${this.currentPage === 1 ? 'disabled' : ''}>
|
||||
←
|
||||
</button>
|
||||
`);
|
||||
|
||||
// Page number buttons
|
||||
let startPage = Math.max(1, this.currentPage - Math.floor(maxButtons / 2));
|
||||
let endPage = Math.min(this.totalPages, startPage + maxButtons - 1);
|
||||
|
||||
if (endPage - startPage + 1 < maxButtons) {
|
||||
startPage = Math.max(1, endPage - maxButtons + 1);
|
||||
}
|
||||
|
||||
for (let i = startPage; i <= endPage; i++) {
|
||||
buttons.push(`
|
||||
<button class="page-btn ${i === this.currentPage ? 'active' : ''}"
|
||||
data-page="${i}">
|
||||
${i}
|
||||
</button>
|
||||
`);
|
||||
}
|
||||
|
||||
// Next button
|
||||
buttons.push(`
|
||||
<button class="page-btn ${this.currentPage === this.totalPages ? 'disabled' : ''}"
|
||||
data-page="${this.currentPage + 1}" ${this.currentPage === this.totalPages ? 'disabled' : ''}>
|
||||
→
|
||||
</button>
|
||||
`);
|
||||
|
||||
return buttons.join('');
|
||||
}
|
||||
|
||||
exportData() {
|
||||
const params = new URLSearchParams({
|
||||
search: this.currentSearch,
|
||||
sort: JSON.stringify(this.currentSort),
|
||||
filters: JSON.stringify(this.currentFilters),
|
||||
format: 'csv'
|
||||
});
|
||||
|
||||
window.open(`${this.config.apiUrl}/export?${params}`, '_blank');
|
||||
}
|
||||
}
|
||||
|
||||
// Auto-initialize tables with data-advanced-table attribute
|
||||
document.addEventListener('DOMContentLoaded', function() {
|
||||
document.querySelectorAll('[data-advanced-table]').forEach(table => {
|
||||
const config = JSON.parse(table.dataset.advancedTable || '{}');
|
||||
new AdvancedTable(table.id, config);
|
||||
});
|
||||
});
|
||||
"""
|
||||
|
||||
def get_advanced_table_css() -> str:
|
||||
"""CSS für erweiterte Tabellen"""
|
||||
return """
|
||||
.table-wrapper {
|
||||
background: white;
|
||||
border-radius: 8px;
|
||||
box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
.table-controls {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
padding: 1rem;
|
||||
background: #f8f9fa;
|
||||
border-bottom: 1px solid #e9ecef;
|
||||
}
|
||||
|
||||
.table-controls-left {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 1rem;
|
||||
}
|
||||
|
||||
.search-box {
|
||||
position: relative;
|
||||
}
|
||||
|
||||
.search-input {
|
||||
padding: 0.5rem 0.75rem;
|
||||
padding-right: 2rem;
|
||||
border: 1px solid #d1d5db;
|
||||
border-radius: 6px;
|
||||
font-size: 0.875rem;
|
||||
}
|
||||
|
||||
.search-icon {
|
||||
position: absolute;
|
||||
right: 0.5rem;
|
||||
top: 50%;
|
||||
transform: translateY(-50%);
|
||||
color: #6b7280;
|
||||
}
|
||||
|
||||
.page-size-selector {
|
||||
display: flex;
|
||||
align-items: center;
|
||||
gap: 0.5rem;
|
||||
font-size: 0.875rem;
|
||||
}
|
||||
|
||||
.table-controls-right {
|
||||
display: flex;
|
||||
gap: 0.5rem;
|
||||
}
|
||||
|
||||
.advanced-table {
|
||||
width: 100%;
|
||||
border-collapse: collapse;
|
||||
}
|
||||
|
||||
.advanced-table th {
|
||||
background: #f8f9fa;
|
||||
padding: 0.75rem;
|
||||
text-align: left;
|
||||
font-weight: 600;
|
||||
border-bottom: 2px solid #e9ecef;
|
||||
position: relative;
|
||||
}
|
||||
|
||||
.advanced-table th[data-sortable="true"] {
|
||||
cursor: pointer;
|
||||
user-select: none;
|
||||
}
|
||||
|
||||
.advanced-table th[data-sortable="true"]:hover {
|
||||
background: #e9ecef;
|
||||
}
|
||||
|
||||
.advanced-table th.sort-asc::after {
|
||||
content: " ↑";
|
||||
color: #3b82f6;
|
||||
}
|
||||
|
||||
.advanced-table th.sort-desc::after {
|
||||
content: " ↓";
|
||||
color: #3b82f6;
|
||||
}
|
||||
|
||||
.advanced-table td {
|
||||
padding: 0.75rem;
|
||||
border-bottom: 1px solid #e9ecef;
|
||||
}
|
||||
|
||||
.advanced-table tbody tr:hover {
|
||||
background: #f8f9fa;
|
||||
}
|
||||
|
||||
.actions-cell {
|
||||
white-space: nowrap;
|
||||
}
|
||||
|
||||
.action-btn {
|
||||
display: inline-block;
|
||||
padding: 0.25rem 0.5rem;
|
||||
margin: 0 0.125rem;
|
||||
font-size: 0.75rem;
|
||||
text-decoration: none;
|
||||
border-radius: 4px;
|
||||
background: #e5e7eb;
|
||||
color: #374151;
|
||||
}
|
||||
|
||||
.action-btn:hover {
|
||||
background: #d1d5db;
|
||||
}
|
||||
|
||||
.action-btn.btn-primary {
|
||||
background: #3b82f6;
|
||||
color: white;
|
||||
}
|
||||
|
||||
.action-btn.btn-danger {
|
||||
background: #ef4444;
|
||||
color: white;
|
||||
}
|
||||
|
||||
.table-pagination {
|
||||
display: flex;
|
||||
justify-content: space-between;
|
||||
align-items: center;
|
||||
padding: 1rem;
|
||||
background: #f8f9fa;
|
||||
border-top: 1px solid #e9ecef;
|
||||
}
|
||||
|
||||
.pagination-controls {
|
||||
display: flex;
|
||||
gap: 0.25rem;
|
||||
}
|
||||
|
||||
.page-btn {
|
||||
padding: 0.5rem 0.75rem;
|
||||
border: 1px solid #d1d5db;
|
||||
background: white;
|
||||
cursor: pointer;
|
||||
border-radius: 4px;
|
||||
}
|
||||
|
||||
.page-btn:hover:not(.disabled) {
|
||||
background: #f3f4f6;
|
||||
}
|
||||
|
||||
.page-btn.active {
|
||||
background: #3b82f6;
|
||||
color: white;
|
||||
border-color: #3b82f6;
|
||||
}
|
||||
|
||||
.page-btn.disabled {
|
||||
opacity: 0.5;
|
||||
cursor: not-allowed;
|
||||
}
|
||||
|
||||
@media (max-width: 768px) {
|
||||
.table-controls {
|
||||
flex-direction: column;
|
||||
gap: 1rem;
|
||||
align-items: stretch;
|
||||
}
|
||||
|
||||
.table-controls-left,
|
||||
.table-controls-right {
|
||||
justify-content: center;
|
||||
}
|
||||
|
||||
.advanced-table {
|
||||
font-size: 0.875rem;
|
||||
}
|
||||
|
||||
.advanced-table th,
|
||||
.advanced-table td {
|
||||
padding: 0.5rem;
|
||||
}
|
||||
|
||||
.table-pagination {
|
||||
flex-direction: column;
|
||||
gap: 1rem;
|
||||
}
|
||||
}
|
||||
"""
|
||||
|
||||
def create_table_config(table_id: str, columns: List[ColumnConfig], **kwargs) -> TableConfig:
|
||||
"""
|
||||
Erstellt eine neue Tabellen-Konfiguration.
|
||||
|
||||
Args:
|
||||
table_id: Eindeutige ID für die Tabelle
|
||||
columns: Liste der Spalten-Konfigurationen
|
||||
**kwargs: Zusätzliche Konfigurationsoptionen
|
||||
|
||||
Returns:
|
||||
TableConfig: Konfiguration für die erweiterte Tabelle
|
||||
"""
|
||||
return TableConfig(
|
||||
table_id=table_id,
|
||||
columns=columns,
|
||||
default_sort=kwargs.get('default_sort', []),
|
||||
default_filters=kwargs.get('default_filters', []),
|
||||
pagination=kwargs.get('pagination', PaginationConfig()),
|
||||
searchable=kwargs.get('searchable', True),
|
||||
exportable=kwargs.get('exportable', True),
|
||||
selectable=kwargs.get('selectable', False),
|
||||
row_actions=kwargs.get('row_actions', [])
|
||||
)
|
||||
|
||||
def get_advanced_tables_js() -> str:
|
||||
"""Alias für die bestehende Funktion"""
|
||||
return get_advanced_table_javascript()
|
||||
|
||||
def get_advanced_tables_css() -> str:
|
||||
"""Alias für die bestehende Funktion"""
|
||||
return get_advanced_table_css()
|
||||
@ -1,667 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Erweiterte Analytik und Statistiken für MYP Platform
|
||||
Umfassende Datenanalyse, Berichte und KPI-Tracking
|
||||
"""
|
||||
|
||||
import json
|
||||
from datetime import datetime, timedelta
|
||||
from typing import Dict, List, Optional, Tuple, Any
|
||||
from sqlalchemy import func, desc, and_, or_, extract
|
||||
from sqlalchemy.orm import Session
|
||||
from dataclasses import dataclass, asdict
|
||||
from enum import Enum
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
logger = get_logger("analytics")
|
||||
|
||||
# ===== ANALYTICS ENUMS =====
|
||||
|
||||
class MetricType(Enum):
|
||||
"""Typen von Metriken"""
|
||||
COUNTER = "counter" # Zähler (erhöht sich)
|
||||
GAUGE = "gauge" # Momentanwert
|
||||
HISTOGRAM = "histogram" # Verteilung von Werten
|
||||
RATE = "rate" # Rate über Zeit
|
||||
|
||||
class TimeRange(Enum):
|
||||
"""Zeiträume für Analysen"""
|
||||
HOUR = "hour"
|
||||
DAY = "day"
|
||||
WEEK = "week"
|
||||
MONTH = "month"
|
||||
QUARTER = "quarter"
|
||||
YEAR = "year"
|
||||
CUSTOM = "custom"
|
||||
|
||||
class ReportFormat(Enum):
|
||||
"""Ausgabeformate für Berichte"""
|
||||
JSON = "json"
|
||||
CSV = "csv"
|
||||
PDF = "pdf"
|
||||
EXCEL = "excel"
|
||||
|
||||
# ===== DATA CLASSES =====
|
||||
|
||||
@dataclass
|
||||
class Metric:
|
||||
"""Einzelne Metrik"""
|
||||
name: str
|
||||
value: float
|
||||
unit: str
|
||||
timestamp: datetime
|
||||
tags: Dict[str, str] = None
|
||||
|
||||
def to_dict(self) -> Dict:
|
||||
result = asdict(self)
|
||||
result['timestamp'] = self.timestamp.isoformat()
|
||||
return result
|
||||
|
||||
@dataclass
|
||||
class AnalyticsData:
|
||||
"""Container für Analytik-Daten"""
|
||||
metrics: List[Metric]
|
||||
timerange: TimeRange
|
||||
start_date: datetime
|
||||
end_date: datetime
|
||||
filters: Dict[str, Any] = None
|
||||
|
||||
def to_dict(self) -> Dict:
|
||||
return {
|
||||
'metrics': [m.to_dict() for m in self.metrics],
|
||||
'timerange': self.timerange.value,
|
||||
'start_date': self.start_date.isoformat(),
|
||||
'end_date': self.end_date.isoformat(),
|
||||
'filters': self.filters or {}
|
||||
}
|
||||
|
||||
@dataclass
|
||||
class KPI:
|
||||
"""Key Performance Indicator"""
|
||||
name: str
|
||||
current_value: float
|
||||
previous_value: float
|
||||
target_value: float
|
||||
unit: str
|
||||
trend: str # "up", "down", "stable"
|
||||
change_percent: float
|
||||
|
||||
def to_dict(self) -> Dict:
|
||||
return asdict(self)
|
||||
|
||||
# ===== ANALYTICS ENGINE =====
|
||||
|
||||
class AnalyticsEngine:
|
||||
"""Hauptklasse für Analytik und Statistiken"""
|
||||
|
||||
def __init__(self):
|
||||
self.cache = {}
|
||||
self.cache_timeout = timedelta(minutes=10)
|
||||
|
||||
def get_printer_statistics(self, time_range: TimeRange = TimeRange.MONTH,
|
||||
start_date: datetime = None, end_date: datetime = None) -> Dict:
|
||||
"""
|
||||
Drucker-Statistiken abrufen
|
||||
|
||||
Args:
|
||||
time_range: Zeitraum für Analyse
|
||||
start_date: Startdatum (optional)
|
||||
end_date: Enddatum (optional)
|
||||
|
||||
Returns:
|
||||
Dict: Drucker-Statistiken
|
||||
"""
|
||||
try:
|
||||
from models import get_db_session, Printer, Job
|
||||
|
||||
if not start_date or not end_date:
|
||||
start_date, end_date = self._get_date_range(time_range)
|
||||
|
||||
db_session = get_db_session()
|
||||
|
||||
# Basis-Statistiken
|
||||
total_printers = db_session.query(Printer).filter(Printer.active == True).count()
|
||||
online_printers = db_session.query(Printer).filter(
|
||||
and_(Printer.active == True, Printer.status.in_(["online", "idle"]))
|
||||
).count()
|
||||
|
||||
# Auslastung nach Druckern
|
||||
printer_usage = db_session.query(
|
||||
Printer.name,
|
||||
func.count(Job.id).label('job_count'),
|
||||
func.sum(Job.duration_minutes).label('total_duration')
|
||||
).outerjoin(Job, and_(
|
||||
Job.printer_id == Printer.id,
|
||||
Job.created_at.between(start_date, end_date)
|
||||
)).group_by(Printer.id, Printer.name).all()
|
||||
|
||||
# Status-Verteilung
|
||||
status_distribution = db_session.query(
|
||||
Printer.status,
|
||||
func.count(Printer.id).label('count')
|
||||
).filter(Printer.active == True).group_by(Printer.status).all()
|
||||
|
||||
# Durchschnittliche Verfügbarkeit
|
||||
availability_stats = self._calculate_printer_availability(db_session, start_date, end_date)
|
||||
|
||||
db_session.close()
|
||||
|
||||
return {
|
||||
'summary': {
|
||||
'total_printers': total_printers,
|
||||
'online_printers': online_printers,
|
||||
'availability_rate': round((online_printers / total_printers * 100) if total_printers > 0 else 0, 1)
|
||||
},
|
||||
'usage_by_printer': [
|
||||
{
|
||||
'name': usage.name,
|
||||
'jobs': usage.job_count or 0,
|
||||
'total_hours': round((usage.total_duration or 0) / 60, 1),
|
||||
'utilization_rate': self._calculate_utilization_rate(usage.total_duration, start_date, end_date)
|
||||
}
|
||||
for usage in printer_usage
|
||||
],
|
||||
'status_distribution': [
|
||||
{'status': status.status, 'count': status.count}
|
||||
for status in status_distribution
|
||||
],
|
||||
'availability': availability_stats,
|
||||
'time_range': {
|
||||
'start': start_date.isoformat(),
|
||||
'end': end_date.isoformat(),
|
||||
'type': time_range.value
|
||||
}
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Abrufen der Drucker-Statistiken: {e}")
|
||||
return {'error': str(e)}
|
||||
|
||||
def get_job_statistics(self, time_range: TimeRange = TimeRange.MONTH,
|
||||
start_date: datetime = None, end_date: datetime = None) -> Dict:
|
||||
"""
|
||||
Job-Statistiken abrufen
|
||||
|
||||
Args:
|
||||
time_range: Zeitraum für Analyse
|
||||
start_date: Startdatum (optional)
|
||||
end_date: Enddatum (optional)
|
||||
|
||||
Returns:
|
||||
Dict: Job-Statistiken
|
||||
"""
|
||||
try:
|
||||
from models import get_db_session, Job, User
|
||||
|
||||
if not start_date or not end_date:
|
||||
start_date, end_date = self._get_date_range(time_range)
|
||||
|
||||
db_session = get_db_session()
|
||||
|
||||
# Basis-Statistiken
|
||||
base_query = db_session.query(Job).filter(
|
||||
Job.created_at.between(start_date, end_date)
|
||||
)
|
||||
|
||||
total_jobs = base_query.count()
|
||||
completed_jobs = base_query.filter(Job.status == 'completed').count()
|
||||
failed_jobs = base_query.filter(Job.status == 'failed').count()
|
||||
cancelled_jobs = base_query.filter(Job.status == 'cancelled').count()
|
||||
|
||||
# Status-Verteilung
|
||||
status_distribution = db_session.query(
|
||||
Job.status,
|
||||
func.count(Job.id).label('count')
|
||||
).filter(
|
||||
Job.created_at.between(start_date, end_date)
|
||||
).group_by(Job.status).all()
|
||||
|
||||
# Durchschnittliche Job-Dauer
|
||||
avg_duration = db_session.query(
|
||||
func.avg(Job.duration_minutes)
|
||||
).filter(
|
||||
and_(
|
||||
Job.created_at.between(start_date, end_date),
|
||||
Job.status == 'completed'
|
||||
)
|
||||
).scalar() or 0
|
||||
|
||||
# Top-Benutzer
|
||||
top_users = db_session.query(
|
||||
User.username,
|
||||
User.name,
|
||||
func.count(Job.id).label('job_count'),
|
||||
func.sum(Job.duration_minutes).label('total_duration')
|
||||
).join(Job).filter(
|
||||
Job.created_at.between(start_date, end_date)
|
||||
).group_by(User.id, User.username, User.name).order_by(
|
||||
desc('job_count')
|
||||
).limit(10).all()
|
||||
|
||||
# Jobs über Zeit (täglich)
|
||||
daily_jobs = self._get_daily_job_trend(db_session, start_date, end_date)
|
||||
|
||||
# Material-Verbrauch (falls verfügbar)
|
||||
material_usage = db_session.query(
|
||||
func.sum(Job.material_used)
|
||||
).filter(
|
||||
and_(
|
||||
Job.created_at.between(start_date, end_date),
|
||||
Job.material_used.isnot(None)
|
||||
)
|
||||
).scalar() or 0
|
||||
|
||||
db_session.close()
|
||||
|
||||
success_rate = round((completed_jobs / total_jobs * 100) if total_jobs > 0 else 0, 1)
|
||||
|
||||
return {
|
||||
'summary': {
|
||||
'total_jobs': total_jobs,
|
||||
'completed_jobs': completed_jobs,
|
||||
'failed_jobs': failed_jobs,
|
||||
'cancelled_jobs': cancelled_jobs,
|
||||
'success_rate': success_rate,
|
||||
'avg_duration_hours': round(avg_duration / 60, 1),
|
||||
'total_material_g': round(material_usage, 1)
|
||||
},
|
||||
'status_distribution': [
|
||||
{'status': status.status, 'count': status.count}
|
||||
for status in status_distribution
|
||||
],
|
||||
'top_users': [
|
||||
{
|
||||
'username': user.username,
|
||||
'name': user.name,
|
||||
'jobs': user.job_count,
|
||||
'total_hours': round((user.total_duration or 0) / 60, 1)
|
||||
}
|
||||
for user in top_users
|
||||
],
|
||||
'daily_trend': daily_jobs,
|
||||
'time_range': {
|
||||
'start': start_date.isoformat(),
|
||||
'end': end_date.isoformat(),
|
||||
'type': time_range.value
|
||||
}
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Abrufen der Job-Statistiken: {e}")
|
||||
return {'error': str(e)}
|
||||
|
||||
def get_user_statistics(self, time_range: TimeRange = TimeRange.MONTH,
|
||||
start_date: datetime = None, end_date: datetime = None) -> Dict:
|
||||
"""
|
||||
Benutzer-Statistiken abrufen
|
||||
|
||||
Args:
|
||||
time_range: Zeitraum für Analyse
|
||||
start_date: Startdatum (optional)
|
||||
end_date: Enddatum (optional)
|
||||
|
||||
Returns:
|
||||
Dict: Benutzer-Statistiken
|
||||
"""
|
||||
try:
|
||||
from models import get_db_session, User, Job
|
||||
|
||||
if not start_date or not end_date:
|
||||
start_date, end_date = self._get_date_range(time_range)
|
||||
|
||||
db_session = get_db_session()
|
||||
|
||||
# Basis-Statistiken
|
||||
total_users = db_session.query(User).filter(User.active == True).count()
|
||||
active_users = db_session.query(func.distinct(Job.user_id)).filter(
|
||||
Job.created_at.between(start_date, end_date)
|
||||
).count()
|
||||
|
||||
# Neue Benutzer im Zeitraum
|
||||
new_users = db_session.query(User).filter(
|
||||
and_(
|
||||
User.created_at.between(start_date, end_date),
|
||||
User.active == True
|
||||
)
|
||||
).count()
|
||||
|
||||
# Benutzer-Aktivität
|
||||
user_activity = db_session.query(
|
||||
User.username,
|
||||
User.name,
|
||||
func.count(Job.id).label('jobs'),
|
||||
func.max(Job.created_at).label('last_activity'),
|
||||
func.sum(Job.duration_minutes).label('total_duration')
|
||||
).outerjoin(Job, and_(
|
||||
Job.user_id == User.id,
|
||||
Job.created_at.between(start_date, end_date)
|
||||
)).filter(User.active == True).group_by(
|
||||
User.id, User.username, User.name
|
||||
).all()
|
||||
|
||||
# Rollenverteilung
|
||||
role_distribution = db_session.query(
|
||||
User.role,
|
||||
func.count(User.id).label('count')
|
||||
).filter(User.active == True).group_by(User.role).all()
|
||||
|
||||
db_session.close()
|
||||
|
||||
# Engagement-Rate berechnen
|
||||
engagement_rate = round((active_users / total_users * 100) if total_users > 0 else 0, 1)
|
||||
|
||||
return {
|
||||
'summary': {
|
||||
'total_users': total_users,
|
||||
'active_users': active_users,
|
||||
'new_users': new_users,
|
||||
'engagement_rate': engagement_rate
|
||||
},
|
||||
'role_distribution': [
|
||||
{'role': role.role or 'user', 'count': role.count}
|
||||
for role in role_distribution
|
||||
],
|
||||
'user_activity': [
|
||||
{
|
||||
'username': user.username,
|
||||
'name': user.name,
|
||||
'jobs': user.jobs or 0,
|
||||
'last_activity': user.last_activity.isoformat() if user.last_activity else None,
|
||||
'total_hours': round((user.total_duration or 0) / 60, 1)
|
||||
}
|
||||
for user in user_activity
|
||||
],
|
||||
'time_range': {
|
||||
'start': start_date.isoformat(),
|
||||
'end': end_date.isoformat(),
|
||||
'type': time_range.value
|
||||
}
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Abrufen der Benutzer-Statistiken: {e}")
|
||||
return {'error': str(e)}
|
||||
|
||||
def get_system_kpis(self, time_range: TimeRange = TimeRange.MONTH) -> Dict:
|
||||
"""
|
||||
System-KPIs abrufen
|
||||
|
||||
Args:
|
||||
time_range: Zeitraum für Vergleich
|
||||
|
||||
Returns:
|
||||
Dict: KPI-Daten
|
||||
"""
|
||||
try:
|
||||
current_start, current_end = self._get_date_range(time_range)
|
||||
previous_start, previous_end = self._get_previous_period(current_start, current_end)
|
||||
|
||||
# Aktuelle Periode
|
||||
current_printer_stats = self.get_printer_statistics(TimeRange.CUSTOM, current_start, current_end)
|
||||
current_job_stats = self.get_job_statistics(TimeRange.CUSTOM, current_start, current_end)
|
||||
current_user_stats = self.get_user_statistics(TimeRange.CUSTOM, current_start, current_end)
|
||||
|
||||
# Vorherige Periode
|
||||
previous_printer_stats = self.get_printer_statistics(TimeRange.CUSTOM, previous_start, previous_end)
|
||||
previous_job_stats = self.get_job_statistics(TimeRange.CUSTOM, previous_start, previous_end)
|
||||
previous_user_stats = self.get_user_statistics(TimeRange.CUSTOM, previous_start, previous_end)
|
||||
|
||||
# KPIs berechnen
|
||||
kpis = [
|
||||
self._create_kpi(
|
||||
name="Drucker-Verfügbarkeit",
|
||||
current=current_printer_stats['summary']['availability_rate'],
|
||||
previous=previous_printer_stats['summary']['availability_rate'],
|
||||
target=95.0,
|
||||
unit="%"
|
||||
),
|
||||
self._create_kpi(
|
||||
name="Job-Erfolgsrate",
|
||||
current=current_job_stats['summary']['success_rate'],
|
||||
previous=previous_job_stats['summary']['success_rate'],
|
||||
target=90.0,
|
||||
unit="%"
|
||||
),
|
||||
self._create_kpi(
|
||||
name="Aktive Benutzer",
|
||||
current=current_user_stats['summary']['active_users'],
|
||||
previous=previous_user_stats['summary']['active_users'],
|
||||
target=50,
|
||||
unit="Benutzer"
|
||||
),
|
||||
self._create_kpi(
|
||||
name="Durchschnittliche Job-Dauer",
|
||||
current=current_job_stats['summary']['avg_duration_hours'],
|
||||
previous=previous_job_stats['summary']['avg_duration_hours'],
|
||||
target=4.0,
|
||||
unit="Stunden"
|
||||
),
|
||||
self._create_kpi(
|
||||
name="Material-Verbrauch",
|
||||
current=current_job_stats['summary']['total_material_g'],
|
||||
previous=previous_job_stats['summary']['total_material_g'],
|
||||
target=10000,
|
||||
unit="g"
|
||||
)
|
||||
]
|
||||
|
||||
return {
|
||||
'kpis': [kpi.to_dict() for kpi in kpis],
|
||||
'period': {
|
||||
'current': {
|
||||
'start': current_start.isoformat(),
|
||||
'end': current_end.isoformat()
|
||||
},
|
||||
'previous': {
|
||||
'start': previous_start.isoformat(),
|
||||
'end': previous_end.isoformat()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Abrufen der System-KPIs: {e}")
|
||||
return {'error': str(e)}
|
||||
|
||||
def generate_report(self, report_type: str, time_range: TimeRange = TimeRange.MONTH,
|
||||
format: ReportFormat = ReportFormat.JSON, **kwargs) -> Dict:
|
||||
"""
|
||||
Bericht generieren
|
||||
|
||||
Args:
|
||||
report_type: Art des Berichts
|
||||
time_range: Zeitraum
|
||||
format: Ausgabeformat
|
||||
**kwargs: Zusätzliche Parameter
|
||||
|
||||
Returns:
|
||||
Dict: Bericht-Daten
|
||||
"""
|
||||
try:
|
||||
start_date = kwargs.get('start_date')
|
||||
end_date = kwargs.get('end_date')
|
||||
|
||||
if not start_date or not end_date:
|
||||
start_date, end_date = self._get_date_range(time_range)
|
||||
|
||||
if report_type == "comprehensive":
|
||||
return self._generate_comprehensive_report(start_date, end_date, format)
|
||||
elif report_type == "printer_usage":
|
||||
return self._generate_printer_usage_report(start_date, end_date, format)
|
||||
elif report_type == "user_activity":
|
||||
return self._generate_user_activity_report(start_date, end_date, format)
|
||||
elif report_type == "efficiency":
|
||||
return self._generate_efficiency_report(start_date, end_date, format)
|
||||
else:
|
||||
raise ValueError(f"Unbekannter Berichtstyp: {report_type}")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Generieren des Berichts: {e}")
|
||||
return {'error': str(e)}
|
||||
|
||||
# ===== HELPER METHODS =====
|
||||
|
||||
def _get_date_range(self, time_range: TimeRange) -> Tuple[datetime, datetime]:
|
||||
"""Berechnet Datumsbereich basierend auf TimeRange"""
|
||||
end_date = datetime.now()
|
||||
|
||||
if time_range == TimeRange.HOUR:
|
||||
start_date = end_date - timedelta(hours=1)
|
||||
elif time_range == TimeRange.DAY:
|
||||
start_date = end_date - timedelta(days=1)
|
||||
elif time_range == TimeRange.WEEK:
|
||||
start_date = end_date - timedelta(weeks=1)
|
||||
elif time_range == TimeRange.MONTH:
|
||||
start_date = end_date - timedelta(days=30)
|
||||
elif time_range == TimeRange.QUARTER:
|
||||
start_date = end_date - timedelta(days=90)
|
||||
elif time_range == TimeRange.YEAR:
|
||||
start_date = end_date - timedelta(days=365)
|
||||
else:
|
||||
start_date = end_date - timedelta(days=30) # Default
|
||||
|
||||
return start_date, end_date
|
||||
|
||||
def _get_previous_period(self, start_date: datetime, end_date: datetime) -> Tuple[datetime, datetime]:
|
||||
"""Berechnet vorherige Periode für Vergleiche"""
|
||||
duration = end_date - start_date
|
||||
previous_end = start_date
|
||||
previous_start = previous_end - duration
|
||||
return previous_start, previous_end
|
||||
|
||||
def _create_kpi(self, name: str, current: float, previous: float,
|
||||
target: float, unit: str) -> KPI:
|
||||
"""Erstellt KPI-Objekt mit Berechnungen"""
|
||||
if previous > 0:
|
||||
change_percent = round(((current - previous) / previous) * 100, 1)
|
||||
else:
|
||||
change_percent = 0.0
|
||||
|
||||
if abs(change_percent) < 1:
|
||||
trend = "stable"
|
||||
elif change_percent > 0:
|
||||
trend = "up"
|
||||
else:
|
||||
trend = "down"
|
||||
|
||||
return KPI(
|
||||
name=name,
|
||||
current_value=current,
|
||||
previous_value=previous,
|
||||
target_value=target,
|
||||
unit=unit,
|
||||
trend=trend,
|
||||
change_percent=change_percent
|
||||
)
|
||||
|
||||
def _calculate_printer_availability(self, db_session: Session,
|
||||
start_date: datetime, end_date: datetime) -> Dict:
|
||||
"""Berechnet Drucker-Verfügbarkeit"""
|
||||
# Vereinfachte Berechnung - kann erweitert werden
|
||||
from models import Printer
|
||||
|
||||
total_printers = db_session.query(Printer).filter(Printer.active == True).count()
|
||||
online_printers = db_session.query(Printer).filter(
|
||||
and_(Printer.active == True, Printer.status.in_(["online", "idle"]))
|
||||
).count()
|
||||
|
||||
availability_rate = round((online_printers / total_printers * 100) if total_printers > 0 else 0, 1)
|
||||
|
||||
return {
|
||||
'total_printers': total_printers,
|
||||
'online_printers': online_printers,
|
||||
'availability_rate': availability_rate,
|
||||
'downtime_hours': 0 # Placeholder - kann mit detaillierter Logging berechnet werden
|
||||
}
|
||||
|
||||
def _calculate_utilization_rate(self, total_minutes: int,
|
||||
start_date: datetime, end_date: datetime) -> float:
|
||||
"""Berechnet Auslastungsrate"""
|
||||
if not total_minutes:
|
||||
return 0.0
|
||||
|
||||
total_hours = (end_date - start_date).total_seconds() / 3600
|
||||
utilization_rate = (total_minutes / 60) / total_hours * 100
|
||||
return round(min(utilization_rate, 100), 1)
|
||||
|
||||
def _get_daily_job_trend(self, db_session: Session,
|
||||
start_date: datetime, end_date: datetime) -> List[Dict]:
|
||||
"""Holt tägliche Job-Trends"""
|
||||
from models import Job
|
||||
|
||||
daily_jobs = db_session.query(
|
||||
func.date(Job.created_at).label('date'),
|
||||
func.count(Job.id).label('count')
|
||||
).filter(
|
||||
Job.created_at.between(start_date, end_date)
|
||||
).group_by(
|
||||
func.date(Job.created_at)
|
||||
).order_by('date').all()
|
||||
|
||||
return [
|
||||
{
|
||||
'date': job.date.isoformat(),
|
||||
'jobs': job.count
|
||||
}
|
||||
for job in daily_jobs
|
||||
]
|
||||
|
||||
def _generate_comprehensive_report(self, start_date: datetime,
|
||||
end_date: datetime, format: ReportFormat) -> Dict:
|
||||
"""Generiert umfassenden Bericht"""
|
||||
printer_stats = self.get_printer_statistics(TimeRange.CUSTOM, start_date, end_date)
|
||||
job_stats = self.get_job_statistics(TimeRange.CUSTOM, start_date, end_date)
|
||||
user_stats = self.get_user_statistics(TimeRange.CUSTOM, start_date, end_date)
|
||||
kpis = self.get_system_kpis(TimeRange.CUSTOM)
|
||||
|
||||
report = {
|
||||
'title': 'Umfassender System-Bericht',
|
||||
'generated_at': datetime.now().isoformat(),
|
||||
'period': {
|
||||
'start': start_date.isoformat(),
|
||||
'end': end_date.isoformat()
|
||||
},
|
||||
'summary': {
|
||||
'total_jobs': job_stats['summary']['total_jobs'],
|
||||
'success_rate': job_stats['summary']['success_rate'],
|
||||
'active_users': user_stats['summary']['active_users'],
|
||||
'printer_availability': printer_stats['summary']['availability_rate']
|
||||
},
|
||||
'sections': {
|
||||
'printers': printer_stats,
|
||||
'jobs': job_stats,
|
||||
'users': user_stats,
|
||||
'kpis': kpis
|
||||
}
|
||||
}
|
||||
|
||||
if format == ReportFormat.JSON:
|
||||
return report
|
||||
else:
|
||||
# Für andere Formate würde hier die Konvertierung stattfinden
|
||||
return {'error': f'Format {format.value} noch nicht implementiert'}
|
||||
|
||||
# ===== GLOBALE INSTANZ =====
|
||||
|
||||
analytics_engine = AnalyticsEngine()
|
||||
|
||||
# ===== UTILITY FUNCTIONS =====
|
||||
|
||||
def get_dashboard_stats() -> Dict:
|
||||
"""Schnelle Dashboard-Statistiken"""
|
||||
return analytics_engine.get_system_kpis(TimeRange.DAY)
|
||||
|
||||
def export_statistics(report_type: str, time_range: TimeRange, format: ReportFormat = ReportFormat.JSON) -> Dict:
|
||||
"""Exportiert Statistiken in verschiedenen Formaten"""
|
||||
return analytics_engine.generate_report(report_type, time_range, format)
|
||||
|
||||
def track_event(event_name: str, properties: Dict = None):
|
||||
"""Verfolgt Events für Analytik"""
|
||||
try:
|
||||
logger.info(f"📊 Event tracked: {event_name} - {properties or {}}")
|
||||
# Hier könnte Event-Tracking implementiert werden
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Event-Tracking: {e}")
|
||||
|
||||
# Logging für Analytics-System
|
||||
logger.info("📈 Analytics Engine initialisiert")
|
||||
@ -1,624 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Erweiterte Druckerkonflikt-Management-Engine - MYP Platform
|
||||
|
||||
Dieses Modul behandelt alle Arten von Druckerkonflikten:
|
||||
- Zeitüberschneidungen
|
||||
- Ressourcenkonflikte
|
||||
- Prioritätskonflikte
|
||||
- Automatische Lösungsfindung
|
||||
- Benutzerbenachrichtigungen
|
||||
"""
|
||||
|
||||
import logging
|
||||
from datetime import datetime, timedelta
|
||||
from typing import List, Dict, Tuple, Optional, Set
|
||||
from dataclasses import dataclass
|
||||
from enum import Enum
|
||||
from sqlalchemy.orm import Session
|
||||
from sqlalchemy import and_, or_
|
||||
|
||||
from models import Job, Printer, User, get_cached_session
|
||||
|
||||
# Logging setup
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
class ConflictType(Enum):
|
||||
"""Konflikttypen im System"""
|
||||
TIME_OVERLAP = "zeitüberschneidung"
|
||||
PRINTER_OFFLINE = "drucker_offline"
|
||||
RESOURCE_UNAVAILABLE = "ressource_nicht_verfügbar"
|
||||
PRIORITY_CONFLICT = "prioritätskonflikt"
|
||||
MAINTENANCE_CONFLICT = "wartungskonflikt"
|
||||
|
||||
class ConflictSeverity(Enum):
|
||||
"""Schweregrade von Konflikten"""
|
||||
CRITICAL = "kritisch" # Verhindert Job-Ausführung komplett
|
||||
HIGH = "hoch" # Beeinträchtigt Job-Qualität stark
|
||||
MEDIUM = "mittel" # Beeinträchtigt Job-Effizienz
|
||||
LOW = "niedrig" # Geringfügige Beeinträchtigung
|
||||
INFO = "information" # Nur informativ
|
||||
|
||||
class ResolutionStrategy(Enum):
|
||||
"""Lösungsstrategien für Konflikte"""
|
||||
AUTO_REASSIGN = "automatische_neuzuweisung"
|
||||
TIME_SHIFT = "zeitverschiebung"
|
||||
PRIORITY_PREEMPTION = "prioritäts_verdrängung"
|
||||
QUEUE_PLACEMENT = "warteschlange"
|
||||
MANUAL_INTERVENTION = "manuelle_behandlung"
|
||||
RESOURCE_SUBSTITUTION = "ressourcen_ersatz"
|
||||
|
||||
@dataclass
|
||||
class ConflictDetails:
|
||||
"""Detaillierte Konfliktinformationen"""
|
||||
conflict_type: ConflictType
|
||||
severity: ConflictSeverity
|
||||
affected_job_id: int
|
||||
conflicting_job_ids: List[int]
|
||||
affected_printer_id: Optional[int]
|
||||
conflict_start: datetime
|
||||
conflict_end: datetime
|
||||
description: str
|
||||
suggested_solutions: List[Dict]
|
||||
estimated_impact: str
|
||||
auto_resolvable: bool
|
||||
|
||||
@dataclass
|
||||
class ConflictResolution:
|
||||
"""Ergebnis einer Konfliktlösung"""
|
||||
success: bool
|
||||
strategy_used: ResolutionStrategy
|
||||
new_printer_id: Optional[int]
|
||||
new_start_time: Optional[datetime]
|
||||
new_end_time: Optional[datetime]
|
||||
affected_jobs: List[int]
|
||||
user_notification_required: bool
|
||||
message: str
|
||||
confidence_score: float
|
||||
|
||||
class ConflictManager:
|
||||
"""Zentrale Konfliktmanagement-Engine"""
|
||||
|
||||
def __init__(self):
|
||||
self.priority_weights = {
|
||||
'urgent': 4,
|
||||
'high': 3,
|
||||
'normal': 2,
|
||||
'low': 1
|
||||
}
|
||||
|
||||
self.time_slot_preferences = {
|
||||
'night_shift': {'start': 18, 'end': 6, 'bonus': 25},
|
||||
'day_shift': {'start': 8, 'end': 17, 'bonus': 15},
|
||||
'transition': {'start': 6, 'end': 8, 'bonus': 5}
|
||||
}
|
||||
|
||||
self.conflict_resolution_timeout = 300 # 5 Minuten
|
||||
|
||||
def detect_conflicts(self, job_data: Dict, db_session: Session) -> List[ConflictDetails]:
|
||||
"""
|
||||
Erkennt alle möglichen Konflikte für einen geplanten Job
|
||||
|
||||
Args:
|
||||
job_data: Job-Informationen (printer_id, start_time, end_time, priority)
|
||||
db_session: Datenbankverbindung
|
||||
|
||||
Returns:
|
||||
Liste aller erkannten Konflikte
|
||||
"""
|
||||
conflicts = []
|
||||
|
||||
# 1. Zeitüberschneidungs-Konflikte prüfen
|
||||
time_conflicts = self._detect_time_conflicts(job_data, db_session)
|
||||
conflicts.extend(time_conflicts)
|
||||
|
||||
# 2. Drucker-Verfügbarkeits-Konflikte prüfen
|
||||
printer_conflicts = self._detect_printer_conflicts(job_data, db_session)
|
||||
conflicts.extend(printer_conflicts)
|
||||
|
||||
# 3. Ressourcen-Konflikte prüfen
|
||||
resource_conflicts = self._detect_resource_conflicts(job_data, db_session)
|
||||
conflicts.extend(resource_conflicts)
|
||||
|
||||
# 4. Prioritäts-Konflikte prüfen
|
||||
priority_conflicts = self._detect_priority_conflicts(job_data, db_session)
|
||||
conflicts.extend(priority_conflicts)
|
||||
|
||||
logger.info(f"🔍 Konfliktanalyse abgeschlossen: {len(conflicts)} Konflikte erkannt")
|
||||
return conflicts
|
||||
|
||||
def _detect_time_conflicts(self, job_data: Dict, db_session: Session) -> List[ConflictDetails]:
|
||||
"""Erkennt Zeitüberschneidungs-Konflikte"""
|
||||
conflicts = []
|
||||
|
||||
printer_id = job_data.get('printer_id')
|
||||
start_time = job_data.get('start_time')
|
||||
end_time = job_data.get('end_time')
|
||||
|
||||
if not all([printer_id, start_time, end_time]):
|
||||
return conflicts
|
||||
|
||||
# Konflikthafte Jobs finden
|
||||
conflicting_jobs = db_session.query(Job).filter(
|
||||
Job.printer_id == printer_id,
|
||||
Job.status.in_(["scheduled", "running"]),
|
||||
or_(
|
||||
and_(Job.start_at >= start_time, Job.start_at < end_time),
|
||||
and_(Job.end_at > start_time, Job.end_at <= end_time),
|
||||
and_(Job.start_at <= start_time, Job.end_at >= end_time)
|
||||
)
|
||||
).all()
|
||||
|
||||
for conflicting_job in conflicting_jobs:
|
||||
# Konflikt-Schweregrad bestimmen
|
||||
overlap_duration = self._calculate_overlap_duration(
|
||||
start_time, end_time,
|
||||
conflicting_job.start_at, conflicting_job.end_at
|
||||
)
|
||||
|
||||
if overlap_duration.total_seconds() > 3600: # > 1 Stunde
|
||||
severity = ConflictSeverity.CRITICAL
|
||||
elif overlap_duration.total_seconds() > 1800: # > 30 Minuten
|
||||
severity = ConflictSeverity.HIGH
|
||||
else:
|
||||
severity = ConflictSeverity.MEDIUM
|
||||
|
||||
# Lösungsvorschläge generieren
|
||||
suggestions = self._generate_time_conflict_solutions(
|
||||
job_data, conflicting_job, db_session
|
||||
)
|
||||
|
||||
conflict = ConflictDetails(
|
||||
conflict_type=ConflictType.TIME_OVERLAP,
|
||||
severity=severity,
|
||||
affected_job_id=job_data.get('job_id', 0),
|
||||
conflicting_job_ids=[conflicting_job.id],
|
||||
affected_printer_id=printer_id,
|
||||
conflict_start=max(start_time, conflicting_job.start_at),
|
||||
conflict_end=min(end_time, conflicting_job.end_at),
|
||||
description=f"Zeitüberschneidung mit Job '{conflicting_job.name}' "
|
||||
f"({overlap_duration.total_seconds()/60:.0f} Minuten)",
|
||||
suggested_solutions=suggestions,
|
||||
estimated_impact=f"Verzögerung von {overlap_duration.total_seconds()/60:.0f} Minuten",
|
||||
auto_resolvable=len(suggestions) > 0
|
||||
)
|
||||
|
||||
conflicts.append(conflict)
|
||||
|
||||
return conflicts
|
||||
|
||||
def _detect_printer_conflicts(self, job_data: Dict, db_session: Session) -> List[ConflictDetails]:
|
||||
"""Erkennt Drucker-Verfügbarkeits-Konflikte"""
|
||||
conflicts = []
|
||||
|
||||
printer_id = job_data.get('printer_id')
|
||||
if not printer_id:
|
||||
return conflicts
|
||||
|
||||
printer = db_session.query(Printer).filter_by(id=printer_id).first()
|
||||
if not printer:
|
||||
conflict = ConflictDetails(
|
||||
conflict_type=ConflictType.PRINTER_OFFLINE,
|
||||
severity=ConflictSeverity.CRITICAL,
|
||||
affected_job_id=job_data.get('job_id', 0),
|
||||
conflicting_job_ids=[],
|
||||
affected_printer_id=printer_id,
|
||||
conflict_start=job_data.get('start_time'),
|
||||
conflict_end=job_data.get('end_time'),
|
||||
description=f"Drucker ID {printer_id} existiert nicht",
|
||||
suggested_solutions=[],
|
||||
estimated_impact="Job kann nicht ausgeführt werden",
|
||||
auto_resolvable=False
|
||||
)
|
||||
conflicts.append(conflict)
|
||||
return conflicts
|
||||
|
||||
# Drucker-Status prüfen
|
||||
if not printer.active:
|
||||
suggestions = self._generate_printer_alternative_solutions(job_data, db_session)
|
||||
|
||||
conflict = ConflictDetails(
|
||||
conflict_type=ConflictType.PRINTER_OFFLINE,
|
||||
severity=ConflictSeverity.HIGH,
|
||||
affected_job_id=job_data.get('job_id', 0),
|
||||
conflicting_job_ids=[],
|
||||
affected_printer_id=printer_id,
|
||||
conflict_start=job_data.get('start_time'),
|
||||
conflict_end=job_data.get('end_time'),
|
||||
description=f"Drucker '{printer.name}' ist offline oder nicht aktiv",
|
||||
suggested_solutions=suggestions,
|
||||
estimated_impact="Automatische Neuzuweisung erforderlich",
|
||||
auto_resolvable=len(suggestions) > 0
|
||||
)
|
||||
conflicts.append(conflict)
|
||||
|
||||
return conflicts
|
||||
|
||||
def _detect_resource_conflicts(self, job_data: Dict, db_session: Session) -> List[ConflictDetails]:
|
||||
"""Erkennt Ressourcen-Verfügbarkeits-Konflikte"""
|
||||
conflicts = []
|
||||
|
||||
# TODO: Implementierung für Material-, Personal- und andere Ressourcenkonflikte
|
||||
# Aktuell Platzhalter für zukünftige Erweiterungen
|
||||
|
||||
return conflicts
|
||||
|
||||
def _detect_priority_conflicts(self, job_data: Dict, db_session: Session) -> List[ConflictDetails]:
|
||||
"""Erkennt Prioritäts-basierte Konflikte"""
|
||||
conflicts = []
|
||||
|
||||
job_priority = job_data.get('priority', 'normal')
|
||||
if job_priority not in ['urgent', 'high']:
|
||||
return conflicts # Nur hohe Prioritäten können andere verdrängen
|
||||
|
||||
printer_id = job_data.get('printer_id')
|
||||
start_time = job_data.get('start_time')
|
||||
end_time = job_data.get('end_time')
|
||||
|
||||
if not all([printer_id, start_time, end_time]):
|
||||
return conflicts
|
||||
|
||||
# Niedrigerprioisierte Jobs im gleichen Zeitraum finden
|
||||
lower_priority_jobs = db_session.query(Job).filter(
|
||||
Job.printer_id == printer_id,
|
||||
Job.status.in_(["scheduled"]),
|
||||
or_(
|
||||
and_(Job.start_at >= start_time, Job.start_at < end_time),
|
||||
and_(Job.end_at > start_time, Job.end_at <= end_time),
|
||||
and_(Job.start_at <= start_time, Job.end_at >= end_time)
|
||||
)
|
||||
).all()
|
||||
|
||||
for existing_job in lower_priority_jobs:
|
||||
existing_priority = getattr(existing_job, 'priority', 'normal')
|
||||
existing_weight = self.priority_weights.get(existing_priority, 2)
|
||||
new_weight = self.priority_weights.get(job_priority, 2)
|
||||
|
||||
if new_weight > existing_weight:
|
||||
suggestions = self._generate_priority_conflict_solutions(
|
||||
job_data, existing_job, db_session
|
||||
)
|
||||
|
||||
conflict = ConflictDetails(
|
||||
conflict_type=ConflictType.PRIORITY_CONFLICT,
|
||||
severity=ConflictSeverity.MEDIUM,
|
||||
affected_job_id=job_data.get('job_id', 0),
|
||||
conflicting_job_ids=[existing_job.id],
|
||||
affected_printer_id=printer_id,
|
||||
conflict_start=start_time,
|
||||
conflict_end=end_time,
|
||||
description=f"Höherpriorer Job verdrängt '{existing_job.name}' "
|
||||
f"({job_priority} > {existing_priority})",
|
||||
suggested_solutions=suggestions,
|
||||
estimated_impact="Umplanung eines bestehenden Jobs erforderlich",
|
||||
auto_resolvable=True
|
||||
)
|
||||
conflicts.append(conflict)
|
||||
|
||||
return conflicts
|
||||
|
||||
def resolve_conflicts(self, conflicts: List[ConflictDetails],
|
||||
job_data: Dict, db_session: Session) -> List[ConflictResolution]:
|
||||
"""
|
||||
Löst alle erkannten Konflikte automatisch oder semi-automatisch
|
||||
|
||||
Args:
|
||||
conflicts: Liste der zu lösenden Konflikte
|
||||
job_data: Job-Informationen
|
||||
db_session: Datenbankverbindung
|
||||
|
||||
Returns:
|
||||
Liste der Konfliktlösungen
|
||||
"""
|
||||
resolutions = []
|
||||
|
||||
# Konflikte nach Schweregrad sortieren (kritische zuerst)
|
||||
sorted_conflicts = sorted(conflicts,
|
||||
key=lambda c: list(ConflictSeverity).index(c.severity))
|
||||
|
||||
for conflict in sorted_conflicts:
|
||||
if conflict.auto_resolvable and conflict.suggested_solutions:
|
||||
resolution = self._auto_resolve_conflict(conflict, job_data, db_session)
|
||||
resolutions.append(resolution)
|
||||
else:
|
||||
# Manuelle Behandlung erforderlich
|
||||
resolution = ConflictResolution(
|
||||
success=False,
|
||||
strategy_used=ResolutionStrategy.MANUAL_INTERVENTION,
|
||||
new_printer_id=None,
|
||||
new_start_time=None,
|
||||
new_end_time=None,
|
||||
affected_jobs=[conflict.affected_job_id],
|
||||
user_notification_required=True,
|
||||
message=f"Manueller Eingriff erforderlich: {conflict.description}",
|
||||
confidence_score=0.0
|
||||
)
|
||||
resolutions.append(resolution)
|
||||
|
||||
logger.info(f"🔧 Konfliktlösung abgeschlossen: {len(resolutions)} Konflikte bearbeitet")
|
||||
return resolutions
|
||||
|
||||
def _auto_resolve_conflict(self, conflict: ConflictDetails,
|
||||
job_data: Dict, db_session: Session) -> ConflictResolution:
|
||||
"""Automatische Konfliktlösung"""
|
||||
|
||||
# Beste Lösung aus Vorschlägen wählen
|
||||
best_solution = max(conflict.suggested_solutions,
|
||||
key=lambda s: s.get('confidence', 0))
|
||||
|
||||
strategy = ResolutionStrategy(best_solution['strategy'])
|
||||
|
||||
try:
|
||||
if strategy == ResolutionStrategy.AUTO_REASSIGN:
|
||||
return self._execute_auto_reassignment(conflict, best_solution, job_data, db_session)
|
||||
elif strategy == ResolutionStrategy.TIME_SHIFT:
|
||||
return self._execute_time_shift(conflict, best_solution, job_data, db_session)
|
||||
elif strategy == ResolutionStrategy.PRIORITY_PREEMPTION:
|
||||
return self._execute_priority_preemption(conflict, best_solution, job_data, db_session)
|
||||
else:
|
||||
raise ValueError(f"Unbekannte Strategie: {strategy}")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"❌ Fehler bei automatischer Konfliktlösung: {str(e)}")
|
||||
return ConflictResolution(
|
||||
success=False,
|
||||
strategy_used=strategy,
|
||||
new_printer_id=None,
|
||||
new_start_time=None,
|
||||
new_end_time=None,
|
||||
affected_jobs=[conflict.affected_job_id],
|
||||
user_notification_required=True,
|
||||
message=f"Automatische Lösung fehlgeschlagen: {str(e)}",
|
||||
confidence_score=0.0
|
||||
)
|
||||
|
||||
def _execute_auto_reassignment(self, conflict: ConflictDetails, solution: Dict,
|
||||
job_data: Dict, db_session: Session) -> ConflictResolution:
|
||||
"""Führt automatische Druckerzuweisung durch"""
|
||||
|
||||
new_printer_id = solution['new_printer_id']
|
||||
printer = db_session.query(Printer).filter_by(id=new_printer_id).first()
|
||||
|
||||
if not printer or not printer.active:
|
||||
return ConflictResolution(
|
||||
success=False,
|
||||
strategy_used=ResolutionStrategy.AUTO_REASSIGN,
|
||||
new_printer_id=None,
|
||||
new_start_time=None,
|
||||
new_end_time=None,
|
||||
affected_jobs=[conflict.affected_job_id],
|
||||
user_notification_required=True,
|
||||
message="Alternativer Drucker nicht mehr verfügbar",
|
||||
confidence_score=0.0
|
||||
)
|
||||
|
||||
return ConflictResolution(
|
||||
success=True,
|
||||
strategy_used=ResolutionStrategy.AUTO_REASSIGN,
|
||||
new_printer_id=new_printer_id,
|
||||
new_start_time=job_data.get('start_time'),
|
||||
new_end_time=job_data.get('end_time'),
|
||||
affected_jobs=[conflict.affected_job_id],
|
||||
user_notification_required=True,
|
||||
message=f"Job automatisch zu Drucker '{printer.name}' verschoben",
|
||||
confidence_score=solution.get('confidence', 0.8)
|
||||
)
|
||||
|
||||
def _execute_time_shift(self, conflict: ConflictDetails, solution: Dict,
|
||||
job_data: Dict, db_session: Session) -> ConflictResolution:
|
||||
"""Führt Zeitverschiebung durch"""
|
||||
|
||||
new_start = solution['new_start_time']
|
||||
new_end = solution['new_end_time']
|
||||
|
||||
return ConflictResolution(
|
||||
success=True,
|
||||
strategy_used=ResolutionStrategy.TIME_SHIFT,
|
||||
new_printer_id=job_data.get('printer_id'),
|
||||
new_start_time=new_start,
|
||||
new_end_time=new_end,
|
||||
affected_jobs=[conflict.affected_job_id],
|
||||
user_notification_required=True,
|
||||
message=f"Job zeitlich verschoben: {new_start.strftime('%H:%M')} - {new_end.strftime('%H:%M')}",
|
||||
confidence_score=solution.get('confidence', 0.7)
|
||||
)
|
||||
|
||||
def _execute_priority_preemption(self, conflict: ConflictDetails, solution: Dict,
|
||||
job_data: Dict, db_session: Session) -> ConflictResolution:
|
||||
"""Führt Prioritätsverdrängung durch"""
|
||||
|
||||
# Bestehenden Job umplanen
|
||||
conflicting_job_id = conflict.conflicting_job_ids[0]
|
||||
affected_jobs = [conflict.affected_job_id, conflicting_job_id]
|
||||
|
||||
return ConflictResolution(
|
||||
success=True,
|
||||
strategy_used=ResolutionStrategy.PRIORITY_PREEMPTION,
|
||||
new_printer_id=job_data.get('printer_id'),
|
||||
new_start_time=job_data.get('start_time'),
|
||||
new_end_time=job_data.get('end_time'),
|
||||
affected_jobs=affected_jobs,
|
||||
user_notification_required=True,
|
||||
message=f"Höherpriorer Job übernimmt Zeitslot, bestehender Job wird umgeplant",
|
||||
confidence_score=solution.get('confidence', 0.9)
|
||||
)
|
||||
|
||||
# Hilfsmethoden für Lösungsvorschläge
|
||||
|
||||
def _generate_time_conflict_solutions(self, job_data: Dict,
|
||||
conflicting_job: Job, db_session: Session) -> List[Dict]:
|
||||
"""Generiert Lösungsvorschläge für Zeitkonflikte"""
|
||||
solutions = []
|
||||
|
||||
# 1. Alternative Drucker vorschlagen
|
||||
alternative_printers = self._find_alternative_printers(job_data, db_session)
|
||||
for printer_id, confidence in alternative_printers:
|
||||
printer = db_session.query(Printer).filter_by(id=printer_id).first()
|
||||
solutions.append({
|
||||
'strategy': ResolutionStrategy.AUTO_REASSIGN.value,
|
||||
'new_printer_id': printer_id,
|
||||
'printer_name': printer.name if printer else f"Drucker {printer_id}",
|
||||
'confidence': confidence,
|
||||
'description': f"Automatische Umzuweisung zu {printer.name if printer else f'Drucker {printer_id}'}"
|
||||
})
|
||||
|
||||
# 2. Zeitverschiebung vorschlagen
|
||||
time_alternatives = self._find_alternative_time_slots(job_data, db_session)
|
||||
for start_time, end_time, confidence in time_alternatives:
|
||||
solutions.append({
|
||||
'strategy': ResolutionStrategy.TIME_SHIFT.value,
|
||||
'new_start_time': start_time,
|
||||
'new_end_time': end_time,
|
||||
'confidence': confidence,
|
||||
'description': f"Zeitverschiebung: {start_time.strftime('%H:%M')} - {end_time.strftime('%H:%M')}"
|
||||
})
|
||||
|
||||
return solutions
|
||||
|
||||
def _generate_printer_alternative_solutions(self, job_data: Dict, db_session: Session) -> List[Dict]:
|
||||
"""Generiert Lösungsvorschläge für Drucker-Ausfälle"""
|
||||
solutions = []
|
||||
|
||||
alternative_printers = self._find_alternative_printers(job_data, db_session)
|
||||
for printer_id, confidence in alternative_printers:
|
||||
printer = db_session.query(Printer).filter_by(id=printer_id).first()
|
||||
solutions.append({
|
||||
'strategy': ResolutionStrategy.AUTO_REASSIGN.value,
|
||||
'new_printer_id': printer_id,
|
||||
'printer_name': printer.name if printer else f"Drucker {printer_id}",
|
||||
'confidence': confidence,
|
||||
'description': f"Automatische Neuzuweisung zu {printer.name if printer else f'Drucker {printer_id}'}"
|
||||
})
|
||||
|
||||
return solutions
|
||||
|
||||
def _generate_priority_conflict_solutions(self, job_data: Dict,
|
||||
existing_job: Job, db_session: Session) -> List[Dict]:
|
||||
"""Generiert Lösungsvorschläge für Prioritätskonflikte"""
|
||||
solutions = []
|
||||
|
||||
# Bestehenden Job umplanen
|
||||
alternative_slots = self._find_alternative_time_slots({
|
||||
'printer_id': existing_job.printer_id,
|
||||
'start_time': existing_job.start_at,
|
||||
'end_time': existing_job.end_at,
|
||||
'duration_minutes': existing_job.duration_minutes
|
||||
}, db_session)
|
||||
|
||||
if alternative_slots:
|
||||
start_time, end_time, confidence = alternative_slots[0]
|
||||
solutions.append({
|
||||
'strategy': ResolutionStrategy.PRIORITY_PREEMPTION.value,
|
||||
'conflicting_job_new_start': start_time,
|
||||
'conflicting_job_new_end': end_time,
|
||||
'confidence': confidence,
|
||||
'description': f"Bestehenden Job zu {start_time.strftime('%H:%M')} verschieben"
|
||||
})
|
||||
|
||||
return solutions
|
||||
|
||||
def _find_alternative_printers(self, job_data: Dict, db_session: Session) -> List[Tuple[int, float]]:
|
||||
"""Findet alternative Drucker mit Confidence-Score"""
|
||||
from blueprints.calendar import get_smart_printer_assignment
|
||||
|
||||
alternatives = []
|
||||
start_time = job_data.get('start_time')
|
||||
end_time = job_data.get('end_time')
|
||||
priority = job_data.get('priority', 'normal')
|
||||
|
||||
# Smart Assignment nutzen
|
||||
recommended_printer_id = get_smart_printer_assignment(
|
||||
start_date=start_time,
|
||||
end_date=end_time,
|
||||
priority=priority,
|
||||
db_session=db_session
|
||||
)
|
||||
|
||||
if recommended_printer_id:
|
||||
alternatives.append((recommended_printer_id, 0.9))
|
||||
|
||||
# Weitere verfügbare Drucker mit niedrigerer Confidence
|
||||
available_printers = db_session.query(Printer).filter(
|
||||
Printer.active == True,
|
||||
Printer.id != job_data.get('printer_id'),
|
||||
Printer.id != recommended_printer_id
|
||||
).all()
|
||||
|
||||
for printer in available_printers[:3]: # Top 3 Alternativen
|
||||
# Einfache Verfügbarkeitsprüfung
|
||||
conflicts = db_session.query(Job).filter(
|
||||
Job.printer_id == printer.id,
|
||||
Job.status.in_(["scheduled", "running"]),
|
||||
or_(
|
||||
and_(Job.start_at >= start_time, Job.start_at < end_time),
|
||||
and_(Job.end_at > start_time, Job.end_at <= end_time),
|
||||
and_(Job.start_at <= start_time, Job.end_at >= end_time)
|
||||
)
|
||||
).count()
|
||||
|
||||
if conflicts == 0:
|
||||
alternatives.append((printer.id, 0.6)) # Niedrigere Confidence
|
||||
|
||||
return alternatives
|
||||
|
||||
def _find_alternative_time_slots(self, job_data: Dict, db_session: Session) -> List[Tuple[datetime, datetime, float]]:
|
||||
"""Findet alternative Zeitfenster"""
|
||||
alternatives = []
|
||||
|
||||
printer_id = job_data.get('printer_id')
|
||||
original_start = job_data.get('start_time')
|
||||
duration_minutes = job_data.get('duration_minutes')
|
||||
|
||||
if not all([printer_id, original_start, duration_minutes]):
|
||||
return alternatives
|
||||
|
||||
duration = timedelta(minutes=duration_minutes)
|
||||
|
||||
# Zeitfenster um ursprünglichen Termin herum testen
|
||||
test_intervals = [
|
||||
timedelta(hours=1), # 1 Stunde später
|
||||
timedelta(hours=2), # 2 Stunden später
|
||||
timedelta(hours=-1), # 1 Stunde früher
|
||||
timedelta(hours=3), # 3 Stunden später
|
||||
timedelta(hours=-2), # 2 Stunden früher
|
||||
]
|
||||
|
||||
for interval in test_intervals:
|
||||
new_start = original_start + interval
|
||||
new_end = new_start + duration
|
||||
|
||||
# Verfügbarkeit prüfen
|
||||
conflicts = db_session.query(Job).filter(
|
||||
Job.printer_id == printer_id,
|
||||
Job.status.in_(["scheduled", "running"]),
|
||||
or_(
|
||||
and_(Job.start_at >= new_start, Job.start_at < new_end),
|
||||
and_(Job.end_at > new_start, Job.end_at <= new_end),
|
||||
and_(Job.start_at <= new_start, Job.end_at >= new_end)
|
||||
)
|
||||
).count()
|
||||
|
||||
if conflicts == 0:
|
||||
# Confidence basierend auf Zeitnähe zum Original
|
||||
time_diff_hours = abs(interval.total_seconds() / 3600)
|
||||
confidence = max(0.3, 1.0 - (time_diff_hours * 0.1))
|
||||
alternatives.append((new_start, new_end, confidence))
|
||||
|
||||
if len(alternatives) >= 3: # Maximal 3 Alternativen
|
||||
break
|
||||
|
||||
return alternatives
|
||||
|
||||
def _calculate_overlap_duration(self, start1: datetime, end1: datetime,
|
||||
start2: datetime, end2: datetime) -> timedelta:
|
||||
"""Berechnet Überschneidungsdauer zwischen zwei Zeiträumen"""
|
||||
overlap_start = max(start1, start2)
|
||||
overlap_end = min(end1, end2)
|
||||
|
||||
if overlap_start < overlap_end:
|
||||
return overlap_end - overlap_start
|
||||
else:
|
||||
return timedelta(0)
|
||||
|
||||
# Globale Instanz für einfache Nutzung
|
||||
conflict_manager = ConflictManager()
|
||||
@ -1,772 +0,0 @@
|
||||
"""
|
||||
Zentralisierte Datenbank-Operationen für das MYP System
|
||||
|
||||
Konsolidierte Implementierung aller datenbankbezogenen Funktionen:
|
||||
- CRUD-Operationen (ursprünglich db_manager.py)
|
||||
- Backup-Verwaltung (ursprünglich database_utils.py)
|
||||
- Cleanup-Operationen (ursprünglich database_cleanup.py)
|
||||
- Einheitliches Session-Management
|
||||
|
||||
Optimierungen:
|
||||
- Intelligente Session-Factory basierend auf Operationstyp
|
||||
- Zentrale Engine-Registry für verschiedene Anwendungsfälle
|
||||
- Koordinierte Lock-Behandlung und Retry-Logik
|
||||
- Vereinheitlichte Error-Handling-Patterns
|
||||
|
||||
Autor: MYP Team - Konsolidiert für IHK-Projektarbeit
|
||||
Datum: 2025-06-09
|
||||
"""
|
||||
|
||||
import os
|
||||
import shutil
|
||||
import sqlite3
|
||||
import threading
|
||||
import time
|
||||
import gzip
|
||||
from datetime import datetime, timedelta
|
||||
from typing import Dict, List, Optional, Tuple, Any, Union
|
||||
from pathlib import Path
|
||||
from contextlib import contextmanager
|
||||
|
||||
from sqlalchemy import text, create_engine
|
||||
from sqlalchemy.engine import Engine
|
||||
from sqlalchemy.orm import sessionmaker, Session
|
||||
from sqlalchemy.exc import SQLAlchemyError, OperationalError
|
||||
|
||||
from utils.settings import DATABASE_PATH
|
||||
from utils.logging_config import get_logger
|
||||
from models import get_cached_session, create_optimized_engine, User, Printer, Job
|
||||
|
||||
# ===== ZENTRALER LOGGER =====
|
||||
db_logger = get_logger("database_core")
|
||||
|
||||
# ===== ENGINE-REGISTRY =====
|
||||
|
||||
class EngineRegistry:
|
||||
"""
|
||||
Zentrale Registry für verschiedene Datenbank-Engine-Konfigurationen.
|
||||
Vermeidet Duplikation und ermöglicht optimierte Engines für verschiedene Anwendungsfälle.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.engines: Dict[str, Engine] = {}
|
||||
self._lock = threading.RLock()
|
||||
|
||||
def get_engine(self, engine_type: str = 'default') -> Engine:
|
||||
"""
|
||||
Holt oder erstellt eine Engine basierend auf dem Typ.
|
||||
|
||||
Args:
|
||||
engine_type: Art der Engine ('default', 'cleanup', 'monitoring', 'backup')
|
||||
|
||||
Returns:
|
||||
Engine: Konfigurierte SQLAlchemy Engine
|
||||
"""
|
||||
with self._lock:
|
||||
if engine_type not in self.engines:
|
||||
self.engines[engine_type] = self._create_engine(engine_type)
|
||||
return self.engines[engine_type]
|
||||
|
||||
def _create_engine(self, engine_type: str) -> Engine:
|
||||
"""Erstellt optimierte Engine basierend auf Anwendungsfall"""
|
||||
base_url = f"sqlite:///{DATABASE_PATH}"
|
||||
|
||||
if engine_type == 'default':
|
||||
# Standard-Engine für CRUD-Operationen
|
||||
return create_optimized_engine()
|
||||
|
||||
elif engine_type == 'cleanup':
|
||||
# Engine für Cleanup-Operationen mit aggressiven Timeouts
|
||||
return create_engine(
|
||||
base_url,
|
||||
pool_timeout=1.0,
|
||||
pool_recycle=300,
|
||||
pool_pre_ping=True,
|
||||
connect_args={
|
||||
'timeout': 5,
|
||||
'check_same_thread': False,
|
||||
'isolation_level': None # Autocommit für Cleanup
|
||||
}
|
||||
)
|
||||
|
||||
elif engine_type == 'monitoring':
|
||||
# Engine für Monitoring mit minimaler Blockierung
|
||||
return create_engine(
|
||||
base_url,
|
||||
pool_timeout=0.5,
|
||||
pool_recycle=60,
|
||||
connect_args={
|
||||
'timeout': 2,
|
||||
'check_same_thread': False
|
||||
}
|
||||
)
|
||||
|
||||
elif engine_type == 'backup':
|
||||
# Engine für Backup-Operationen mit längeren Timeouts
|
||||
return create_engine(
|
||||
base_url,
|
||||
pool_timeout=30.0,
|
||||
pool_recycle=3600,
|
||||
connect_args={
|
||||
'timeout': 30,
|
||||
'check_same_thread': False
|
||||
}
|
||||
)
|
||||
|
||||
else:
|
||||
db_logger.warning(f"Unknown engine type '{engine_type}', using default")
|
||||
return create_optimized_engine()
|
||||
|
||||
def dispose_all(self):
|
||||
"""Schließt alle registrierten Engines"""
|
||||
with self._lock:
|
||||
for engine_type, engine in self.engines.items():
|
||||
try:
|
||||
engine.dispose()
|
||||
db_logger.debug(f"Engine '{engine_type}' disposed successfully")
|
||||
except Exception as e:
|
||||
db_logger.warning(f"Error disposing engine '{engine_type}': {e}")
|
||||
self.engines.clear()
|
||||
|
||||
# Globale Engine-Registry
|
||||
engine_registry = EngineRegistry()
|
||||
|
||||
# ===== SESSION-MANAGEMENT =====
|
||||
|
||||
@contextmanager
|
||||
def get_database_session(operation_type: str = 'default'):
|
||||
"""
|
||||
Intelligenter Session-Manager basierend auf Operationstyp.
|
||||
|
||||
Args:
|
||||
operation_type: Art der Operation ('default', 'cleanup', 'monitoring', 'backup', 'cached')
|
||||
|
||||
Yields:
|
||||
Session: Konfigurierte SQLAlchemy Session
|
||||
"""
|
||||
if operation_type == 'cached':
|
||||
# Verwende das bestehende Cached-Session-System für Standard-CRUD
|
||||
session = get_cached_session()
|
||||
try:
|
||||
yield session
|
||||
finally:
|
||||
# Cached Sessions werden automatisch verwaltet
|
||||
pass
|
||||
else:
|
||||
# Erstelle neue Session für spezielle Operationen
|
||||
engine = engine_registry.get_engine(operation_type)
|
||||
SessionClass = sessionmaker(bind=engine)
|
||||
session = SessionClass()
|
||||
|
||||
try:
|
||||
yield session
|
||||
except Exception as e:
|
||||
try:
|
||||
session.rollback()
|
||||
db_logger.error(f"Session rollback for {operation_type}: {e}")
|
||||
except Exception as rollback_error:
|
||||
db_logger.error(f"Session rollback failed for {operation_type}: {rollback_error}")
|
||||
raise
|
||||
finally:
|
||||
try:
|
||||
session.close()
|
||||
except Exception as close_error:
|
||||
db_logger.warning(f"Session close failed for {operation_type}: {close_error}")
|
||||
|
||||
# ===== CLEANUP-OPERATIONEN =====
|
||||
|
||||
class DatabaseCleanupManager:
|
||||
"""
|
||||
Robuste Cleanup-Operationen mit intelligenter Retry-Logik.
|
||||
Konsolidiert Funktionalität aus database_cleanup.py.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.cleanup_logger = get_logger("database_cleanup")
|
||||
self._registered_engines = set()
|
||||
|
||||
def register_engine_for_cleanup(self, engine: Engine):
|
||||
"""Registriert Engine für Cleanup bei WAL-Operationen"""
|
||||
self._registered_engines.add(engine)
|
||||
|
||||
def force_close_all_connections(self):
|
||||
"""Schließt alle offenen Datenbankverbindungen forciert"""
|
||||
try:
|
||||
# Standard-Engine-Registry schließen
|
||||
engine_registry.dispose_all()
|
||||
|
||||
# Registrierte Engines schließen
|
||||
for engine in self._registered_engines:
|
||||
try:
|
||||
engine.dispose()
|
||||
except Exception as e:
|
||||
self.cleanup_logger.warning(f"Failed to dispose registered engine: {e}")
|
||||
|
||||
self._registered_engines.clear()
|
||||
|
||||
# Warten auf Verbindungsschließung
|
||||
time.sleep(0.5)
|
||||
|
||||
self.cleanup_logger.info("All database connections forcefully closed")
|
||||
|
||||
except Exception as e:
|
||||
self.cleanup_logger.error(f"Error during connection cleanup: {e}")
|
||||
|
||||
def perform_wal_checkpoint(self, retries: int = 3) -> bool:
|
||||
"""
|
||||
Führt WAL-Checkpoint mit Retry-Logik durch.
|
||||
|
||||
Args:
|
||||
retries: Anzahl der Wiederholungsversuche
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich
|
||||
"""
|
||||
for attempt in range(retries):
|
||||
try:
|
||||
if attempt > 0:
|
||||
self.force_close_all_connections()
|
||||
time.sleep(1.0 * attempt) # Exponential backoff
|
||||
|
||||
# Direkte SQLite3-Verbindung für maximale Kontrolle
|
||||
conn = sqlite3.connect(DATABASE_PATH, timeout=10.0)
|
||||
cursor = conn.cursor()
|
||||
|
||||
try:
|
||||
# WAL-Checkpoint durchführen
|
||||
cursor.execute("PRAGMA wal_checkpoint(TRUNCATE)")
|
||||
result = cursor.fetchone()
|
||||
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
self.cleanup_logger.info(f"WAL checkpoint successful on attempt {attempt + 1}: {result}")
|
||||
return True
|
||||
|
||||
except sqlite3.OperationalError as e:
|
||||
conn.close()
|
||||
if "database is locked" in str(e).lower() and attempt < retries - 1:
|
||||
self.cleanup_logger.warning(f"Database locked on attempt {attempt + 1}, retrying...")
|
||||
continue
|
||||
else:
|
||||
raise
|
||||
|
||||
except Exception as e:
|
||||
self.cleanup_logger.error(f"WAL checkpoint attempt {attempt + 1} failed: {e}")
|
||||
if attempt == retries - 1:
|
||||
return False
|
||||
|
||||
return False
|
||||
|
||||
def switch_journal_mode(self, mode: str = "WAL") -> bool:
|
||||
"""
|
||||
Wechselt den Journal-Modus der Datenbank.
|
||||
|
||||
Args:
|
||||
mode: Journal-Modus ('WAL', 'DELETE', 'TRUNCATE', etc.)
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich
|
||||
"""
|
||||
try:
|
||||
self.force_close_all_connections()
|
||||
time.sleep(1.0)
|
||||
|
||||
conn = sqlite3.connect(DATABASE_PATH, timeout=15.0)
|
||||
cursor = conn.cursor()
|
||||
|
||||
try:
|
||||
cursor.execute(f"PRAGMA journal_mode = {mode}")
|
||||
result = cursor.fetchone()
|
||||
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
self.cleanup_logger.info(f"Journal mode switched to {mode}: {result}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
conn.close()
|
||||
self.cleanup_logger.error(f"Failed to switch journal mode to {mode}: {e}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
self.cleanup_logger.error(f"Error during journal mode switch: {e}")
|
||||
return False
|
||||
|
||||
# ===== BACKUP-OPERATIONEN =====
|
||||
|
||||
class DatabaseBackupManager:
|
||||
"""
|
||||
Erweiterte Backup-Verwaltung mit automatischer Rotation.
|
||||
Konsolidiert Funktionalität aus database_utils.py.
|
||||
"""
|
||||
|
||||
def __init__(self, backup_dir: str = None):
|
||||
self.backup_dir = backup_dir or os.path.join(os.path.dirname(DATABASE_PATH), "backups")
|
||||
self.backup_logger = get_logger("database_backup")
|
||||
self.ensure_backup_directory()
|
||||
self._backup_lock = threading.Lock()
|
||||
|
||||
def ensure_backup_directory(self):
|
||||
"""Stellt sicher, dass das Backup-Verzeichnis existiert"""
|
||||
Path(self.backup_dir).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
def create_backup(self, compress: bool = True) -> str:
|
||||
"""
|
||||
Erstellt ein Backup der Datenbank.
|
||||
|
||||
Args:
|
||||
compress: Ob das Backup komprimiert werden soll
|
||||
|
||||
Returns:
|
||||
str: Pfad zum erstellten Backup
|
||||
"""
|
||||
with self._backup_lock:
|
||||
try:
|
||||
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
|
||||
extension = '.gz' if compress else '.db'
|
||||
backup_filename = f"myp_backup_{timestamp}.db{extension}"
|
||||
backup_path = os.path.join(self.backup_dir, backup_filename)
|
||||
|
||||
# Checkpoint vor Backup
|
||||
cleanup_manager = DatabaseCleanupManager()
|
||||
cleanup_manager.perform_wal_checkpoint()
|
||||
|
||||
if compress:
|
||||
# Komprimiertes Backup
|
||||
with open(DATABASE_PATH, 'rb') as f_in:
|
||||
with gzip.open(backup_path, 'wb') as f_out:
|
||||
shutil.copyfileobj(f_in, f_out)
|
||||
else:
|
||||
# Einfache Kopie
|
||||
shutil.copy2(DATABASE_PATH, backup_path)
|
||||
|
||||
backup_size = os.path.getsize(backup_path)
|
||||
self.backup_logger.info(f"Backup created: {backup_filename} ({backup_size / 1024 / 1024:.2f} MB)")
|
||||
|
||||
return backup_path
|
||||
|
||||
except Exception as e:
|
||||
self.backup_logger.error(f"Backup creation failed: {e}")
|
||||
raise
|
||||
|
||||
def list_backups(self) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Listet alle verfügbaren Backups auf.
|
||||
|
||||
Returns:
|
||||
List[Dict]: Liste der Backup-Informationen
|
||||
"""
|
||||
try:
|
||||
backups = []
|
||||
backup_pattern = "myp_backup_*.db*"
|
||||
|
||||
for backup_file in Path(self.backup_dir).glob(backup_pattern):
|
||||
stat = backup_file.stat()
|
||||
backups.append({
|
||||
'filename': backup_file.name,
|
||||
'path': str(backup_file),
|
||||
'size_bytes': stat.st_size,
|
||||
'size_mb': round(stat.st_size / 1024 / 1024, 2),
|
||||
'created_at': datetime.fromtimestamp(stat.st_ctime),
|
||||
'compressed': backup_file.suffix == '.gz'
|
||||
})
|
||||
|
||||
# Sortiere nach Datum (neueste zuerst)
|
||||
backups.sort(key=lambda x: x['created_at'], reverse=True)
|
||||
return backups
|
||||
|
||||
except Exception as e:
|
||||
self.backup_logger.error(f"Error listing backups: {e}")
|
||||
return []
|
||||
|
||||
def cleanup_old_backups(self, keep_count: int = 10) -> int:
|
||||
"""
|
||||
Räumt alte Backups auf und behält nur die neuesten.
|
||||
|
||||
Args:
|
||||
keep_count: Anzahl der zu behaltenden Backups
|
||||
|
||||
Returns:
|
||||
int: Anzahl der gelöschten Backups
|
||||
"""
|
||||
try:
|
||||
backups = self.list_backups()
|
||||
if len(backups) <= keep_count:
|
||||
return 0
|
||||
|
||||
backups_to_delete = backups[keep_count:]
|
||||
deleted_count = 0
|
||||
|
||||
for backup in backups_to_delete:
|
||||
try:
|
||||
os.remove(backup['path'])
|
||||
deleted_count += 1
|
||||
self.backup_logger.debug(f"Deleted old backup: {backup['filename']}")
|
||||
except Exception as e:
|
||||
self.backup_logger.warning(f"Failed to delete backup {backup['filename']}: {e}")
|
||||
|
||||
self.backup_logger.info(f"Cleaned up {deleted_count} old backups, kept {keep_count}")
|
||||
return deleted_count
|
||||
|
||||
except Exception as e:
|
||||
self.backup_logger.error(f"Error during backup cleanup: {e}")
|
||||
return 0
|
||||
|
||||
def restore_backup(self, backup_path: str) -> bool:
|
||||
"""
|
||||
Stellt ein Backup wieder her.
|
||||
|
||||
Args:
|
||||
backup_path: Pfad zur Backup-Datei
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich
|
||||
"""
|
||||
try:
|
||||
if not os.path.exists(backup_path):
|
||||
self.backup_logger.error(f"Backup file not found: {backup_path}")
|
||||
return False
|
||||
|
||||
# Verbindungen schließen
|
||||
cleanup_manager = DatabaseCleanupManager()
|
||||
cleanup_manager.force_close_all_connections()
|
||||
time.sleep(2.0)
|
||||
|
||||
# Aktueller Datenbank-Backup erstellen
|
||||
current_backup = self.create_backup(compress=True)
|
||||
self.backup_logger.info(f"Current database backed up to: {current_backup}")
|
||||
|
||||
# Backup wiederherstellen
|
||||
if backup_path.endswith('.gz'):
|
||||
# Komprimiertes Backup entpacken
|
||||
with gzip.open(backup_path, 'rb') as f_in:
|
||||
with open(DATABASE_PATH, 'wb') as f_out:
|
||||
shutil.copyfileobj(f_in, f_out)
|
||||
else:
|
||||
# Einfache Kopie
|
||||
shutil.copy2(backup_path, DATABASE_PATH)
|
||||
|
||||
self.backup_logger.info(f"Database restored from: {backup_path}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
self.backup_logger.error(f"Backup restoration failed: {e}")
|
||||
return False
|
||||
|
||||
# ===== CRUD-OPERATIONEN =====
|
||||
|
||||
class DatabaseCRUDManager:
|
||||
"""
|
||||
Geschäftslogik-orientierte CRUD-Operationen.
|
||||
Konsolidiert Funktionalität aus db_manager.py.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.crud_logger = get_logger("database_crud")
|
||||
|
||||
def get_active_jobs(self, limit: int = None) -> List[Job]:
|
||||
"""
|
||||
Holt aktive Jobs mit optimiertem Loading.
|
||||
|
||||
Args:
|
||||
limit: Maximale Anzahl Jobs
|
||||
|
||||
Returns:
|
||||
List[Job]: Liste der aktiven Jobs
|
||||
"""
|
||||
try:
|
||||
with get_database_session('cached') as session:
|
||||
query = session.query(Job).filter(
|
||||
Job.status.in_(['pending', 'printing', 'paused'])
|
||||
).order_by(Job.created_at.desc())
|
||||
|
||||
if limit:
|
||||
query = query.limit(limit)
|
||||
|
||||
jobs = query.all()
|
||||
self.crud_logger.debug(f"Retrieved {len(jobs)} active jobs")
|
||||
return jobs
|
||||
|
||||
except Exception as e:
|
||||
self.crud_logger.error(f"Error retrieving active jobs: {e}")
|
||||
return []
|
||||
|
||||
def get_printer_with_jobs(self, printer_id: int) -> Optional[Printer]:
|
||||
"""
|
||||
Holt Drucker mit zugehörigen Jobs (Eager Loading).
|
||||
|
||||
Args:
|
||||
printer_id: ID des Druckers
|
||||
|
||||
Returns:
|
||||
Optional[Printer]: Drucker mit Jobs oder None
|
||||
"""
|
||||
try:
|
||||
with get_database_session('cached') as session:
|
||||
from sqlalchemy.orm import joinedload
|
||||
|
||||
printer = session.query(Printer).options(
|
||||
joinedload(Printer.jobs)
|
||||
).filter(Printer.id == printer_id).first()
|
||||
|
||||
if printer:
|
||||
self.crud_logger.debug(f"Retrieved printer {printer.name} with {len(printer.jobs)} jobs")
|
||||
|
||||
return printer
|
||||
|
||||
except Exception as e:
|
||||
self.crud_logger.error(f"Error retrieving printer with jobs: {e}")
|
||||
return None
|
||||
|
||||
def get_user_job_statistics(self, user_id: int) -> Dict[str, Any]:
|
||||
"""
|
||||
Holt Benutzer-Job-Statistiken.
|
||||
|
||||
Args:
|
||||
user_id: ID des Benutzers
|
||||
|
||||
Returns:
|
||||
Dict: Statistiken des Benutzers
|
||||
"""
|
||||
try:
|
||||
with get_database_session('cached') as session:
|
||||
user = session.query(User).filter(User.id == user_id).first()
|
||||
if not user:
|
||||
return {}
|
||||
|
||||
# Job-Statistiken berechnen
|
||||
total_jobs = session.query(Job).filter(Job.user_id == user_id).count()
|
||||
completed_jobs = session.query(Job).filter(
|
||||
Job.user_id == user_id, Job.status == 'completed'
|
||||
).count()
|
||||
active_jobs = session.query(Job).filter(
|
||||
Job.user_id == user_id, Job.status.in_(['pending', 'printing', 'paused'])
|
||||
).count()
|
||||
|
||||
stats = {
|
||||
'user_id': user_id,
|
||||
'username': user.username,
|
||||
'total_jobs': total_jobs,
|
||||
'completed_jobs': completed_jobs,
|
||||
'active_jobs': active_jobs,
|
||||
'success_rate': round((completed_jobs / total_jobs * 100), 2) if total_jobs > 0 else 0
|
||||
}
|
||||
|
||||
self.crud_logger.debug(f"Generated statistics for user {user.username}")
|
||||
return stats
|
||||
|
||||
except Exception as e:
|
||||
self.crud_logger.error(f"Error generating user statistics: {e}")
|
||||
return {}
|
||||
|
||||
# ===== MONITORING-OPERATIONEN =====
|
||||
|
||||
class DatabaseMonitor:
|
||||
"""
|
||||
Performance-Überwachung und Gesundheitsprüfungen.
|
||||
Erweitert Funktionalität aus database_utils.py.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.monitor_logger = get_logger("database_monitor")
|
||||
|
||||
def get_database_health_check(self) -> Dict[str, Any]:
|
||||
"""
|
||||
Umfassende Gesundheitsprüfung der Datenbank.
|
||||
|
||||
Returns:
|
||||
Dict: Gesundheitsstatus der Datenbank
|
||||
"""
|
||||
health_status = {
|
||||
'timestamp': datetime.now().isoformat(),
|
||||
'overall_status': 'unknown',
|
||||
'checks': {}
|
||||
}
|
||||
|
||||
try:
|
||||
with get_database_session('monitoring') as session:
|
||||
# 1. Verbindungstest
|
||||
try:
|
||||
session.execute(text("SELECT 1"))
|
||||
health_status['checks']['connection'] = {'status': 'ok', 'message': 'Database connection successful'}
|
||||
except Exception as e:
|
||||
health_status['checks']['connection'] = {'status': 'error', 'message': str(e)}
|
||||
|
||||
# 2. Integritätsprüfung
|
||||
try:
|
||||
result = session.execute(text("PRAGMA integrity_check")).fetchone()
|
||||
integrity_ok = result and result[0] == 'ok'
|
||||
health_status['checks']['integrity'] = {
|
||||
'status': 'ok' if integrity_ok else 'warning',
|
||||
'message': result[0] if result else 'No integrity result'
|
||||
}
|
||||
except Exception as e:
|
||||
health_status['checks']['integrity'] = {'status': 'error', 'message': str(e)}
|
||||
|
||||
# 3. WAL-Status
|
||||
try:
|
||||
wal_result = session.execute(text("PRAGMA journal_mode")).fetchone()
|
||||
wal_mode = wal_result[0] if wal_result else 'unknown'
|
||||
health_status['checks']['wal_mode'] = {
|
||||
'status': 'ok' if wal_mode == 'wal' else 'info',
|
||||
'message': f'Journal mode: {wal_mode}'
|
||||
}
|
||||
except Exception as e:
|
||||
health_status['checks']['wal_mode'] = {'status': 'error', 'message': str(e)}
|
||||
|
||||
# 4. Datenbankgröße
|
||||
try:
|
||||
if os.path.exists(DATABASE_PATH):
|
||||
db_size = os.path.getsize(DATABASE_PATH)
|
||||
health_status['checks']['database_size'] = {
|
||||
'status': 'ok',
|
||||
'message': f'Database size: {db_size / 1024 / 1024:.2f} MB',
|
||||
'size_bytes': db_size
|
||||
}
|
||||
except Exception as e:
|
||||
health_status['checks']['database_size'] = {'status': 'error', 'message': str(e)}
|
||||
|
||||
# Gesamtstatus bestimmen
|
||||
statuses = [check['status'] for check in health_status['checks'].values()]
|
||||
if 'error' in statuses:
|
||||
health_status['overall_status'] = 'error'
|
||||
elif 'warning' in statuses:
|
||||
health_status['overall_status'] = 'warning'
|
||||
else:
|
||||
health_status['overall_status'] = 'ok'
|
||||
|
||||
except Exception as e:
|
||||
health_status['overall_status'] = 'error'
|
||||
health_status['error'] = str(e)
|
||||
self.monitor_logger.error(f"Database health check failed: {e}")
|
||||
|
||||
return health_status
|
||||
|
||||
# ===== UNIFIED DATABASE SERVICE =====
|
||||
|
||||
class UnifiedDatabaseService:
|
||||
"""
|
||||
Zentrale Schnittstelle für alle Datenbankoperationen.
|
||||
Kombiniert CRUD, Wartung, Cleanup und Monitoring.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.logger = get_logger("unified_database")
|
||||
self.crud = DatabaseCRUDManager()
|
||||
self.backup = DatabaseBackupManager()
|
||||
self.cleanup = DatabaseCleanupManager()
|
||||
self.monitor = DatabaseMonitor()
|
||||
|
||||
# Engines für Cleanup registrieren
|
||||
for engine_type in ['default', 'monitoring', 'backup']:
|
||||
engine = engine_registry.get_engine(engine_type)
|
||||
self.cleanup.register_engine_for_cleanup(engine)
|
||||
|
||||
def get_service_status(self) -> Dict[str, Any]:
|
||||
"""
|
||||
Holt den Status aller Datenbankdienste.
|
||||
|
||||
Returns:
|
||||
Dict: Umfassender Service-Status
|
||||
"""
|
||||
try:
|
||||
health_check = self.monitor.get_database_health_check()
|
||||
backups = self.backup.list_backups()
|
||||
|
||||
return {
|
||||
'timestamp': datetime.now().isoformat(),
|
||||
'health': health_check,
|
||||
'backups': {
|
||||
'count': len(backups),
|
||||
'latest': backups[0] if backups else None
|
||||
},
|
||||
'engines': {
|
||||
'registered_count': len(engine_registry.engines),
|
||||
'types': list(engine_registry.engines.keys())
|
||||
}
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Error getting service status: {e}")
|
||||
return {'error': str(e), 'timestamp': datetime.now().isoformat()}
|
||||
|
||||
def perform_maintenance(self) -> Dict[str, Any]:
|
||||
"""
|
||||
Führt umfassende Datenbankwartung durch.
|
||||
|
||||
Returns:
|
||||
Dict: Wartungsergebnisse
|
||||
"""
|
||||
maintenance_results = {
|
||||
'timestamp': datetime.now().isoformat(),
|
||||
'operations': {}
|
||||
}
|
||||
|
||||
try:
|
||||
# 1. WAL-Checkpoint
|
||||
self.logger.info("Starting WAL checkpoint...")
|
||||
checkpoint_success = self.cleanup.perform_wal_checkpoint()
|
||||
maintenance_results['operations']['wal_checkpoint'] = {
|
||||
'success': checkpoint_success,
|
||||
'message': 'WAL checkpoint completed' if checkpoint_success else 'WAL checkpoint failed'
|
||||
}
|
||||
|
||||
# 2. Backup erstellen
|
||||
self.logger.info("Creating maintenance backup...")
|
||||
try:
|
||||
backup_path = self.backup.create_backup(compress=True)
|
||||
maintenance_results['operations']['backup'] = {
|
||||
'success': True,
|
||||
'message': f'Backup created: {os.path.basename(backup_path)}',
|
||||
'path': backup_path
|
||||
}
|
||||
except Exception as e:
|
||||
maintenance_results['operations']['backup'] = {
|
||||
'success': False,
|
||||
'message': f'Backup failed: {str(e)}'
|
||||
}
|
||||
|
||||
# 3. Alte Backups aufräumen
|
||||
self.logger.info("Cleaning up old backups...")
|
||||
try:
|
||||
deleted_count = self.backup.cleanup_old_backups(keep_count=10)
|
||||
maintenance_results['operations']['backup_cleanup'] = {
|
||||
'success': True,
|
||||
'message': f'Cleaned up {deleted_count} old backups'
|
||||
}
|
||||
except Exception as e:
|
||||
maintenance_results['operations']['backup_cleanup'] = {
|
||||
'success': False,
|
||||
'message': f'Backup cleanup failed: {str(e)}'
|
||||
}
|
||||
|
||||
# 4. Gesundheitsprüfung
|
||||
self.logger.info("Performing health check...")
|
||||
health_check = self.monitor.get_database_health_check()
|
||||
maintenance_results['health_check'] = health_check
|
||||
|
||||
# Gesamtergebnis
|
||||
operation_results = [op['success'] for op in maintenance_results['operations'].values()]
|
||||
maintenance_results['overall_success'] = all(operation_results)
|
||||
|
||||
self.logger.info(f"Maintenance completed with overall success: {maintenance_results['overall_success']}")
|
||||
|
||||
except Exception as e:
|
||||
self.logger.error(f"Maintenance operation failed: {e}")
|
||||
maintenance_results['error'] = str(e)
|
||||
maintenance_results['overall_success'] = False
|
||||
|
||||
return maintenance_results
|
||||
|
||||
# ===== GLOBALE INSTANZ =====
|
||||
|
||||
# Zentrale Datenbankdienst-Instanz
|
||||
database_service = UnifiedDatabaseService()
|
||||
|
||||
# Cleanup-Manager für Legacy-Kompatibilität
|
||||
cleanup_manager = database_service.cleanup
|
||||
|
||||
# Backup-Manager für Legacy-Kompatibilität
|
||||
backup_manager = database_service.backup
|
||||
@ -1,252 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Database Migration Utility für MYP Platform
|
||||
Überprüft und aktualisiert die Datenbankschema automatisch.
|
||||
"""
|
||||
|
||||
import sqlite3
|
||||
import logging
|
||||
from typing import List, Dict, Any
|
||||
from datetime import datetime
|
||||
|
||||
from utils.settings import DATABASE_PATH
|
||||
from models import init_db
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
def get_table_columns(table_name: str) -> List[Dict[str, Any]]:
|
||||
"""
|
||||
Ruft die Spalten einer Tabelle ab.
|
||||
|
||||
Args:
|
||||
table_name: Name der Tabelle
|
||||
|
||||
Returns:
|
||||
List[Dict]: Liste der Spalten mit ihren Eigenschaften
|
||||
"""
|
||||
try:
|
||||
conn = sqlite3.connect(DATABASE_PATH)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(f'PRAGMA table_info({table_name})')
|
||||
columns = cursor.fetchall()
|
||||
conn.close()
|
||||
|
||||
return [
|
||||
{
|
||||
'name': col[1],
|
||||
'type': col[2],
|
||||
'not_null': bool(col[3]),
|
||||
'default': col[4],
|
||||
'primary_key': bool(col[5])
|
||||
}
|
||||
for col in columns
|
||||
]
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Abrufen der Spalten für Tabelle {table_name}: {e}")
|
||||
return []
|
||||
|
||||
def table_exists(table_name: str) -> bool:
|
||||
"""
|
||||
Prüft, ob eine Tabelle existiert.
|
||||
|
||||
Args:
|
||||
table_name: Name der Tabelle
|
||||
|
||||
Returns:
|
||||
bool: True wenn die Tabelle existiert
|
||||
"""
|
||||
try:
|
||||
conn = sqlite3.connect(DATABASE_PATH)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("""
|
||||
SELECT name FROM sqlite_master
|
||||
WHERE type='table' AND name=?
|
||||
""", (table_name,))
|
||||
result = cursor.fetchone()
|
||||
conn.close()
|
||||
return result is not None
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Prüfen der Tabelle {table_name}: {e}")
|
||||
return False
|
||||
|
||||
def column_exists(table_name: str, column_name: str) -> bool:
|
||||
"""
|
||||
Prüft, ob eine Spalte in einer Tabelle existiert.
|
||||
|
||||
Args:
|
||||
table_name: Name der Tabelle
|
||||
column_name: Name der Spalte
|
||||
|
||||
Returns:
|
||||
bool: True wenn die Spalte existiert
|
||||
"""
|
||||
columns = get_table_columns(table_name)
|
||||
return any(col['name'] == column_name for col in columns)
|
||||
|
||||
def add_column_if_missing(table_name: str, column_name: str, column_type: str, default_value: str = None) -> bool:
|
||||
"""
|
||||
Fügt eine Spalte hinzu, falls sie nicht existiert.
|
||||
|
||||
Args:
|
||||
table_name: Name der Tabelle
|
||||
column_name: Name der Spalte
|
||||
column_type: Datentyp der Spalte
|
||||
default_value: Optional - Standardwert
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich
|
||||
"""
|
||||
if column_exists(table_name, column_name):
|
||||
logger.info(f"Spalte {column_name} existiert bereits in Tabelle {table_name}")
|
||||
return True
|
||||
|
||||
try:
|
||||
conn = sqlite3.connect(DATABASE_PATH)
|
||||
cursor = conn.cursor()
|
||||
|
||||
sql = f"ALTER TABLE {table_name} ADD COLUMN {column_name} {column_type}"
|
||||
if default_value:
|
||||
sql += f" DEFAULT {default_value}"
|
||||
|
||||
cursor.execute(sql)
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
logger.info(f"Spalte {column_name} erfolgreich zu Tabelle {table_name} hinzugefügt")
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Hinzufügen der Spalte {column_name} zu Tabelle {table_name}: {e}")
|
||||
return False
|
||||
|
||||
def migrate_database() -> bool:
|
||||
"""
|
||||
Führt alle notwendigen Datenbankmigrationen durch.
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich
|
||||
"""
|
||||
logger.info("Starte Datenbankmigration...")
|
||||
|
||||
try:
|
||||
# Prüfe, ob grundlegende Tabellen existieren
|
||||
required_tables = ['users', 'printers', 'jobs', 'stats']
|
||||
missing_tables = [table for table in required_tables if not table_exists(table)]
|
||||
|
||||
if missing_tables:
|
||||
logger.warning(f"Fehlende Tabellen gefunden: {missing_tables}")
|
||||
logger.info("Erstelle alle Tabellen neu...")
|
||||
init_db()
|
||||
logger.info("Tabellen erfolgreich erstellt")
|
||||
return True
|
||||
|
||||
# Prüfe spezifische Spalten, die möglicherweise fehlen
|
||||
migrations = [
|
||||
# Printers Tabelle
|
||||
('printers', 'last_checked', 'DATETIME', 'NULL'),
|
||||
('printers', 'active', 'BOOLEAN', '1'),
|
||||
('printers', 'created_at', 'DATETIME', 'CURRENT_TIMESTAMP'),
|
||||
|
||||
# Jobs Tabelle
|
||||
('jobs', 'duration_minutes', 'INTEGER', '60'),
|
||||
('jobs', 'actual_end_time', 'DATETIME', 'NULL'),
|
||||
('jobs', 'owner_id', 'INTEGER', 'NULL'),
|
||||
('jobs', 'file_path', 'VARCHAR(500)', 'NULL'),
|
||||
|
||||
# Users Tabelle
|
||||
('users', 'username', 'VARCHAR(100)', 'NULL'),
|
||||
('users', 'active', 'BOOLEAN', '1'),
|
||||
('users', 'created_at', 'DATETIME', 'CURRENT_TIMESTAMP'),
|
||||
]
|
||||
|
||||
success = True
|
||||
for table_name, column_name, column_type, default_value in migrations:
|
||||
if not add_column_if_missing(table_name, column_name, column_type, default_value):
|
||||
success = False
|
||||
|
||||
if success:
|
||||
logger.info("Datenbankmigration erfolgreich abgeschlossen")
|
||||
else:
|
||||
logger.warning("Datenbankmigration mit Fehlern abgeschlossen")
|
||||
|
||||
return success
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei der Datenbankmigration: {e}")
|
||||
return False
|
||||
|
||||
def check_database_integrity() -> bool:
|
||||
"""
|
||||
Überprüft die Integrität der Datenbank.
|
||||
|
||||
Returns:
|
||||
bool: True wenn die Datenbank integer ist
|
||||
"""
|
||||
try:
|
||||
conn = sqlite3.connect(DATABASE_PATH)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute('PRAGMA integrity_check')
|
||||
result = cursor.fetchone()
|
||||
conn.close()
|
||||
|
||||
if result and result[0] == 'ok':
|
||||
logger.info("Datenbankintegrität: OK")
|
||||
return True
|
||||
else:
|
||||
logger.error(f"Datenbankintegrität: FEHLER - {result}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei der Integritätsprüfung: {e}")
|
||||
return False
|
||||
|
||||
def backup_database(backup_path: str = None) -> bool:
|
||||
"""
|
||||
Erstellt ein Backup der Datenbank.
|
||||
|
||||
Args:
|
||||
backup_path: Optional - Pfad für das Backup
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich
|
||||
"""
|
||||
if not backup_path:
|
||||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
backup_path = f"database/myp_backup_{timestamp}.db"
|
||||
|
||||
try:
|
||||
import shutil
|
||||
shutil.copy2(DATABASE_PATH, backup_path)
|
||||
logger.info(f"Datenbank-Backup erstellt: {backup_path}")
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Erstellen des Backups: {e}")
|
||||
return False
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Logging konfigurieren
|
||||
logging.basicConfig(
|
||||
level=logging.INFO,
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
|
||||
)
|
||||
|
||||
print("=== MYP Platform - Datenbankmigration ===")
|
||||
|
||||
# Backup erstellen
|
||||
if backup_database():
|
||||
print("✅ Backup erstellt")
|
||||
else:
|
||||
print("⚠️ Backup-Erstellung fehlgeschlagen")
|
||||
|
||||
# Integrität prüfen
|
||||
if check_database_integrity():
|
||||
print("✅ Datenbankintegrität OK")
|
||||
else:
|
||||
print("❌ Datenbankintegrität FEHLER")
|
||||
|
||||
# Migration durchführen
|
||||
if migrate_database():
|
||||
print("✅ Migration erfolgreich")
|
||||
else:
|
||||
print("❌ Migration fehlgeschlagen")
|
||||
|
||||
print("\nMigration abgeschlossen!")
|
||||
@ -1,290 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Optimiertes Datenbank-Schema-Migrationsskript
|
||||
Mit WAL-Checkpoint und ordnungsgemäßer Ressourcenverwaltung
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import sqlite3
|
||||
import signal
|
||||
import time
|
||||
from datetime import datetime
|
||||
import logging
|
||||
from contextlib import contextmanager
|
||||
|
||||
# Pfad zur App hinzufügen - KORRIGIERT
|
||||
app_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
sys.path.insert(0, app_dir)
|
||||
|
||||
# Alternative Datenbankpfad-Definition falls Import fehlschlägt
|
||||
DATABASE_PATH = None
|
||||
try:
|
||||
from utils.settings import DATABASE_PATH
|
||||
except ImportError:
|
||||
# Fallback: Datenbankpfad manuell setzen
|
||||
DATABASE_PATH = os.path.join(app_dir, "database", "myp.db")
|
||||
print(f"⚠️ Fallback: Verwende Datenbankpfad: {DATABASE_PATH}")
|
||||
|
||||
# Logging-Setup mit Fallback
|
||||
try:
|
||||
from utils.logging_config import get_logger
|
||||
logger = get_logger("schema_migration")
|
||||
except ImportError:
|
||||
# Fallback: Standard-Logging
|
||||
logging.basicConfig(level=logging.INFO)
|
||||
logger = logging.getLogger("schema_migration")
|
||||
|
||||
# Globale Variable für sauberes Shutdown
|
||||
_migration_running = False
|
||||
_current_connection = None
|
||||
|
||||
def signal_handler(signum, frame):
|
||||
"""Signal-Handler für ordnungsgemäßes Shutdown"""
|
||||
global _migration_running, _current_connection
|
||||
print(f"\n🛑 Signal {signum} empfangen - beende Migration sauber...")
|
||||
_migration_running = False
|
||||
|
||||
if _current_connection:
|
||||
try:
|
||||
print("🔄 Führe WAL-Checkpoint durch...")
|
||||
_current_connection.execute("PRAGMA wal_checkpoint(TRUNCATE)")
|
||||
_current_connection.commit()
|
||||
_current_connection.close()
|
||||
print("✅ Datenbank ordnungsgemäß geschlossen")
|
||||
except Exception as e:
|
||||
print(f"⚠️ Fehler beim Schließen: {e}")
|
||||
|
||||
print("🏁 Migration beendet")
|
||||
sys.exit(0)
|
||||
|
||||
# Signal-Handler registrieren
|
||||
signal.signal(signal.SIGINT, signal_handler)
|
||||
signal.signal(signal.SIGTERM, signal_handler)
|
||||
|
||||
@contextmanager
|
||||
def get_database_connection(timeout=30):
|
||||
"""Context Manager für sichere Datenbankverbindung mit WAL-Optimierung"""
|
||||
global _current_connection
|
||||
conn = None
|
||||
|
||||
try:
|
||||
# Verbindung mit optimierten Einstellungen
|
||||
conn = sqlite3.connect(
|
||||
DATABASE_PATH,
|
||||
timeout=timeout,
|
||||
isolation_level=None # Autocommit aus für manuelle Transaktionen
|
||||
)
|
||||
_current_connection = conn
|
||||
|
||||
# WAL-Modus und Optimierungen
|
||||
conn.execute("PRAGMA journal_mode=WAL")
|
||||
conn.execute("PRAGMA synchronous=NORMAL") # Bessere Performance mit WAL
|
||||
conn.execute("PRAGMA foreign_keys=ON")
|
||||
conn.execute("PRAGMA busy_timeout=30000") # 30 Sekunden Timeout
|
||||
conn.execute("PRAGMA wal_autocheckpoint=1000") # Automatischer Checkpoint alle 1000 Seiten
|
||||
|
||||
logger.info("Datenbankverbindung mit WAL-Optimierungen hergestellt")
|
||||
yield conn
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Datenbankverbindungsfehler: {e}")
|
||||
if conn:
|
||||
conn.rollback()
|
||||
raise
|
||||
finally:
|
||||
if conn:
|
||||
try:
|
||||
# Kritisch: WAL-Checkpoint vor dem Schließen
|
||||
logger.info("Führe finalen WAL-Checkpoint durch...")
|
||||
conn.execute("PRAGMA wal_checkpoint(TRUNCATE)")
|
||||
conn.commit()
|
||||
|
||||
# Prüfe WAL-Status
|
||||
wal_info = conn.execute("PRAGMA wal_checkpoint").fetchone()
|
||||
if wal_info:
|
||||
logger.info(f"WAL-Checkpoint: {wal_info[0]} Seiten übertragen, {wal_info[1]} Seiten zurückgesetzt")
|
||||
|
||||
conn.close()
|
||||
logger.info("Datenbankverbindung ordnungsgemäß geschlossen")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Schließen der Datenbankverbindung: {e}")
|
||||
finally:
|
||||
_current_connection = None
|
||||
|
||||
def force_wal_checkpoint():
|
||||
"""Erzwingt WAL-Checkpoint um alle Daten in die Hauptdatei zu schreiben"""
|
||||
try:
|
||||
with get_database_connection(timeout=10) as conn:
|
||||
# Aggressive WAL-Checkpoint-Strategien
|
||||
strategies = [
|
||||
("TRUNCATE", "Vollständiger Checkpoint mit WAL-Truncate"),
|
||||
("RESTART", "Checkpoint mit WAL-Restart"),
|
||||
("FULL", "Vollständiger Checkpoint")
|
||||
]
|
||||
|
||||
for strategy, description in strategies:
|
||||
try:
|
||||
result = conn.execute(f"PRAGMA wal_checkpoint({strategy})").fetchone()
|
||||
if result and result[0] == 0: # Erfolg
|
||||
logger.info(f"✅ {description} erfolgreich: {result}")
|
||||
return True
|
||||
else:
|
||||
logger.warning(f"⚠️ {description} teilweise erfolgreich: {result}")
|
||||
except Exception as e:
|
||||
logger.warning(f"⚠️ {description} fehlgeschlagen: {e}")
|
||||
continue
|
||||
|
||||
# Fallback: VACUUM für komplette Reorganisation
|
||||
logger.info("Führe VACUUM als Fallback durch...")
|
||||
conn.execute("VACUUM")
|
||||
logger.info("✅ VACUUM erfolgreich")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Kritischer Fehler bei WAL-Checkpoint: {e}")
|
||||
return False
|
||||
|
||||
def optimize_migration_performance():
|
||||
"""Optimiert die Datenbank für die Migration"""
|
||||
try:
|
||||
with get_database_connection(timeout=5) as conn:
|
||||
# Performance-Optimierungen für Migration
|
||||
optimizations = [
|
||||
("PRAGMA cache_size = -64000", "Cache-Größe auf 64MB erhöht"),
|
||||
("PRAGMA temp_store = MEMORY", "Temp-Store in Memory"),
|
||||
("PRAGMA mmap_size = 268435456", "Memory-Mapped I/O aktiviert"),
|
||||
("PRAGMA optimize", "Automatische Optimierungen")
|
||||
]
|
||||
|
||||
for pragma, description in optimizations:
|
||||
try:
|
||||
conn.execute(pragma)
|
||||
logger.info(f"✅ {description}")
|
||||
except Exception as e:
|
||||
logger.warning(f"⚠️ Optimierung fehlgeschlagen ({description}): {e}")
|
||||
|
||||
except Exception as e:
|
||||
logger.warning(f"Fehler bei Performance-Optimierung: {e}")
|
||||
|
||||
def main():
|
||||
"""Führt die optimierte Schema-Migration aus."""
|
||||
global _migration_running
|
||||
_migration_running = True
|
||||
|
||||
try:
|
||||
logger.info("🚀 Starte optimierte Datenbank-Schema-Migration...")
|
||||
|
||||
# Überprüfe Datenbankdatei
|
||||
if not os.path.exists(DATABASE_PATH):
|
||||
logger.error(f"❌ Datenbankdatei nicht gefunden: {DATABASE_PATH}")
|
||||
return False
|
||||
|
||||
# Initial WAL-Checkpoint um sauberen Zustand sicherzustellen
|
||||
logger.info("🔄 Führe initialen WAL-Checkpoint durch...")
|
||||
force_wal_checkpoint()
|
||||
|
||||
# Performance-Optimierungen
|
||||
optimize_migration_performance()
|
||||
|
||||
# Eigentliche Migration mit optimierter Verbindung
|
||||
with get_database_connection(timeout=60) as conn:
|
||||
cursor = conn.cursor()
|
||||
|
||||
# Backup erstellen (mit Timeout)
|
||||
backup_path = f"{DATABASE_PATH}.backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
|
||||
try:
|
||||
logger.info(f"📦 Erstelle Backup: {backup_path}")
|
||||
cursor.execute(f"VACUUM INTO '{backup_path}'")
|
||||
logger.info("✅ Backup erfolgreich erstellt")
|
||||
except Exception as e:
|
||||
logger.warning(f"⚠️ Backup-Erstellung fehlgeschlagen: {e}")
|
||||
|
||||
# Migrationen durchführen (verkürzt für bessere Performance)
|
||||
migrations_performed = []
|
||||
|
||||
if not _migration_running:
|
||||
return False
|
||||
|
||||
# Schnelle Schema-Checks
|
||||
try:
|
||||
# Test der kritischen Abfrage
|
||||
cursor.execute("SELECT COUNT(*) FROM guest_requests WHERE duration_minutes IS NOT NULL")
|
||||
logger.info("✅ Schema-Integritätstest bestanden")
|
||||
except Exception:
|
||||
logger.info("🔧 Führe kritische Schema-Reparaturen durch...")
|
||||
|
||||
# Nur die wichtigsten Reparaturen
|
||||
critical_fixes = [
|
||||
("ALTER TABLE guest_requests ADD COLUMN duration_minutes INTEGER", "duration_minutes zu guest_requests"),
|
||||
("ALTER TABLE users ADD COLUMN username VARCHAR(100)", "username zu users"),
|
||||
("UPDATE users SET username = email WHERE username IS NULL", "Username-Fallback")
|
||||
]
|
||||
|
||||
for sql, description in critical_fixes:
|
||||
if not _migration_running:
|
||||
break
|
||||
try:
|
||||
cursor.execute(sql)
|
||||
logger.info(f"✅ {description}")
|
||||
migrations_performed.append(description)
|
||||
except sqlite3.OperationalError as e:
|
||||
if "duplicate column" not in str(e).lower():
|
||||
logger.warning(f"⚠️ {description}: {e}")
|
||||
|
||||
# Commit und WAL-Checkpoint zwischen Operationen
|
||||
if migrations_performed:
|
||||
conn.commit()
|
||||
cursor.execute("PRAGMA wal_checkpoint(PASSIVE)")
|
||||
|
||||
# Finale Optimierungen (reduziert)
|
||||
if _migration_running:
|
||||
essential_indices = [
|
||||
"CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)",
|
||||
"CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status)",
|
||||
"CREATE INDEX IF NOT EXISTS idx_guest_requests_status ON guest_requests(status)"
|
||||
]
|
||||
|
||||
for index_sql in essential_indices:
|
||||
try:
|
||||
cursor.execute(index_sql)
|
||||
except Exception:
|
||||
pass # Indices sind nicht kritisch
|
||||
|
||||
# Finale Statistiken
|
||||
cursor.execute("ANALYZE")
|
||||
migrations_performed.append("optimizations")
|
||||
|
||||
# Finale Commit
|
||||
conn.commit()
|
||||
logger.info(f"✅ Migration abgeschlossen. Bereiche: {', '.join(migrations_performed)}")
|
||||
|
||||
# Abschließender WAL-Checkpoint
|
||||
logger.info("🔄 Führe abschließenden WAL-Checkpoint durch...")
|
||||
force_wal_checkpoint()
|
||||
|
||||
# Kurze Pause um sicherzustellen, dass alle I/O-Operationen abgeschlossen sind
|
||||
time.sleep(1)
|
||||
|
||||
logger.info("🎉 Optimierte Schema-Migration erfolgreich abgeschlossen!")
|
||||
return True
|
||||
|
||||
except KeyboardInterrupt:
|
||||
logger.info("🔄 Migration durch Benutzer unterbrochen")
|
||||
return False
|
||||
except Exception as e:
|
||||
logger.error(f"❌ Kritischer Fehler bei der Migration: {str(e)}")
|
||||
return False
|
||||
finally:
|
||||
_migration_running = False
|
||||
# Finale WAL-Bereinigung
|
||||
try:
|
||||
force_wal_checkpoint()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = main()
|
||||
if not success:
|
||||
sys.exit(1)
|
||||
278
backend/utils/database_suite.py
Normal file
278
backend/utils/database_suite.py
Normal file
@ -0,0 +1,278 @@
|
||||
#!/usr/bin/env python3.11
|
||||
"""
|
||||
Database Suite - FINALE ULTRA KONSOLIDIERUNG
|
||||
============================================
|
||||
|
||||
Migration Information:
|
||||
- Ursprünglich: database_core.py, database_utils.py, database_migration.py,
|
||||
database_schema_migration.py, fix_database_immediate.py, migrate_db.py,
|
||||
migrate_user_settings.py, test_database_cleanup.py
|
||||
- Konsolidiert am: 2025-06-09
|
||||
- Funktionalitäten: DB-Core, Utilities, Migrationen, Fixes, Cleanup
|
||||
- Breaking Changes: Keine - Alle Original-APIs bleiben verfügbar
|
||||
|
||||
FINALE ULTRA KONSOLIDIERUNG für Projektarbeit MYP
|
||||
Author: MYP Team - Till Tomczak
|
||||
Ziel: DRASTISCHE Datei-Reduktion!
|
||||
"""
|
||||
|
||||
import os
|
||||
import sqlite3
|
||||
import shutil
|
||||
from datetime import datetime
|
||||
from typing import Dict, List, Any, Optional
|
||||
from sqlalchemy import create_engine, text, inspect
|
||||
from sqlalchemy.orm import sessionmaker
|
||||
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
# Logger
|
||||
db_logger = get_logger("database_suite")
|
||||
|
||||
# ===== DATABASE CORE =====
|
||||
|
||||
class DatabaseCore:
|
||||
"""Database-Core-Management"""
|
||||
|
||||
def __init__(self):
|
||||
self.database_path = "backend/database/myp.db"
|
||||
self.backup_path = "backend/database/backups/"
|
||||
|
||||
def get_connection(self):
|
||||
"""Holt Datenbank-Verbindung"""
|
||||
return sqlite3.connect(self.database_path)
|
||||
|
||||
def execute_query(self, query: str, params=None) -> List[tuple]:
|
||||
"""Führt Query aus"""
|
||||
try:
|
||||
conn = self.get_connection()
|
||||
cursor = conn.cursor()
|
||||
|
||||
if params:
|
||||
cursor.execute(query, params)
|
||||
else:
|
||||
cursor.execute(query)
|
||||
|
||||
result = cursor.fetchall()
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
return result
|
||||
except Exception as e:
|
||||
db_logger.error(f"Query-Fehler: {e}")
|
||||
return []
|
||||
|
||||
def backup_database(self) -> bool:
|
||||
"""Erstellt Datenbank-Backup"""
|
||||
try:
|
||||
os.makedirs(self.backup_path, exist_ok=True)
|
||||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
backup_file = f"{self.backup_path}myp_backup_{timestamp}.db"
|
||||
|
||||
shutil.copy2(self.database_path, backup_file)
|
||||
db_logger.info(f"Backup erstellt: {backup_file}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
db_logger.error(f"Backup-Fehler: {e}")
|
||||
return False
|
||||
|
||||
# ===== DATABASE UTILITIES =====
|
||||
|
||||
class DatabaseUtils:
|
||||
"""Datenbank-Hilfsfunktionen"""
|
||||
|
||||
def __init__(self):
|
||||
self.db_core = DatabaseCore()
|
||||
|
||||
def get_table_info(self, table_name: str) -> List[Dict]:
|
||||
"""Holt Tabellen-Info"""
|
||||
query = f"PRAGMA table_info({table_name})"
|
||||
result = self.db_core.execute_query(query)
|
||||
|
||||
return [
|
||||
{
|
||||
'cid': row[0],
|
||||
'name': row[1],
|
||||
'type': row[2],
|
||||
'notnull': row[3],
|
||||
'default': row[4],
|
||||
'pk': row[5]
|
||||
}
|
||||
for row in result
|
||||
]
|
||||
|
||||
def get_all_tables(self) -> List[str]:
|
||||
"""Holt alle Tabellen"""
|
||||
query = "SELECT name FROM sqlite_master WHERE type='table'"
|
||||
result = self.db_core.execute_query(query)
|
||||
return [row[0] for row in result]
|
||||
|
||||
def count_rows(self, table_name: str) -> int:
|
||||
"""Zählt Zeilen in Tabelle"""
|
||||
query = f"SELECT COUNT(*) FROM {table_name}"
|
||||
result = self.db_core.execute_query(query)
|
||||
return result[0][0] if result else 0
|
||||
|
||||
# ===== DATABASE MIGRATION =====
|
||||
|
||||
class DatabaseMigration:
|
||||
"""Datenbank-Migrationen"""
|
||||
|
||||
def __init__(self):
|
||||
self.db_core = DatabaseCore()
|
||||
self.db_utils = DatabaseUtils()
|
||||
|
||||
def migrate_user_settings(self) -> bool:
|
||||
"""Migriert Benutzer-Einstellungen"""
|
||||
try:
|
||||
# Backup vor Migration
|
||||
self.db_core.backup_database()
|
||||
|
||||
# Check if user_settings column exists
|
||||
user_info = self.db_utils.get_table_info('users')
|
||||
has_settings = any(col['name'] == 'user_settings' for col in user_info)
|
||||
|
||||
if not has_settings:
|
||||
# Add user_settings column
|
||||
query = "ALTER TABLE users ADD COLUMN user_settings TEXT"
|
||||
self.db_core.execute_query(query)
|
||||
db_logger.info("user_settings Spalte hinzugefügt")
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
db_logger.error(f"User-Settings Migration Fehler: {e}")
|
||||
return False
|
||||
|
||||
def fix_database_immediate(self) -> bool:
|
||||
"""Sofortige Datenbank-Fixes"""
|
||||
try:
|
||||
# Backup
|
||||
self.db_core.backup_database()
|
||||
|
||||
# Fix common issues
|
||||
fixes = [
|
||||
"UPDATE jobs SET status = 'pending' WHERE status IS NULL",
|
||||
"UPDATE printers SET status = 'offline' WHERE status IS NULL",
|
||||
"UPDATE users SET role = 'user' WHERE role IS NULL"
|
||||
]
|
||||
|
||||
for fix in fixes:
|
||||
self.db_core.execute_query(fix)
|
||||
|
||||
db_logger.info("Sofortige Datenbank-Fixes angewendet")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
db_logger.error(f"Immediate Fix Fehler: {e}")
|
||||
return False
|
||||
|
||||
# ===== DATABASE CLEANUP =====
|
||||
|
||||
class DatabaseCleanup:
|
||||
"""Datenbank-Bereinigung"""
|
||||
|
||||
def __init__(self):
|
||||
self.db_core = DatabaseCore()
|
||||
|
||||
def cleanup_old_jobs(self, days: int = 30) -> int:
|
||||
"""Löscht alte Jobs"""
|
||||
try:
|
||||
query = f"""
|
||||
DELETE FROM jobs
|
||||
WHERE created_at < datetime('now', '-{days} days')
|
||||
AND status IN ('completed', 'failed')
|
||||
"""
|
||||
|
||||
conn = self.db_core.get_connection()
|
||||
cursor = conn.cursor()
|
||||
cursor.execute(query)
|
||||
deleted = cursor.rowcount
|
||||
conn.commit()
|
||||
conn.close()
|
||||
|
||||
db_logger.info(f"{deleted} alte Jobs gelöscht")
|
||||
return deleted
|
||||
|
||||
except Exception as e:
|
||||
db_logger.error(f"Job-Cleanup Fehler: {e}")
|
||||
return 0
|
||||
|
||||
def vacuum_database(self) -> bool:
|
||||
"""Komprimiert Datenbank"""
|
||||
try:
|
||||
self.db_core.execute_query("VACUUM")
|
||||
db_logger.info("Datenbank komprimiert")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
db_logger.error(f"Vacuum Fehler: {e}")
|
||||
return False
|
||||
|
||||
# ===== GLOBALE INSTANZEN =====
|
||||
|
||||
database_core = DatabaseCore()
|
||||
database_utils = DatabaseUtils()
|
||||
database_migration = DatabaseMigration()
|
||||
database_cleanup = DatabaseCleanup()
|
||||
|
||||
# ===== CONVENIENCE FUNCTIONS =====
|
||||
|
||||
def backup_database() -> bool:
|
||||
"""Erstellt Datenbank-Backup"""
|
||||
return database_core.backup_database()
|
||||
|
||||
def get_database_stats() -> Dict[str, Any]:
|
||||
"""Holt Datenbank-Statistiken"""
|
||||
try:
|
||||
tables = database_utils.get_all_tables()
|
||||
stats = {'total_tables': len(tables), 'tables': {}}
|
||||
|
||||
for table in tables:
|
||||
stats['tables'][table] = database_utils.count_rows(table)
|
||||
|
||||
return stats
|
||||
except Exception as e:
|
||||
db_logger.error(f"Stats Fehler: {e}")
|
||||
return {'error': str(e)}
|
||||
|
||||
def run_database_maintenance() -> bool:
|
||||
"""Führt Datenbank-Wartung aus"""
|
||||
try:
|
||||
# Cleanup
|
||||
database_cleanup.cleanup_old_jobs()
|
||||
|
||||
# Vacuum
|
||||
database_cleanup.vacuum_database()
|
||||
|
||||
# Backup
|
||||
database_core.backup_database()
|
||||
|
||||
db_logger.info("Datenbank-Wartung abgeschlossen")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
db_logger.error(f"Wartung Fehler: {e}")
|
||||
return False
|
||||
|
||||
# ===== LEGACY COMPATIBILITY =====
|
||||
|
||||
# Original database_core.py compatibility
|
||||
def get_db_connection():
|
||||
return database_core.get_connection()
|
||||
|
||||
# Original database_utils.py compatibility
|
||||
def get_table_names():
|
||||
return database_utils.get_all_tables()
|
||||
|
||||
# Original database_migration.py compatibility
|
||||
def run_migrations():
|
||||
return database_migration.migrate_user_settings()
|
||||
|
||||
# Original database_cleanup.py compatibility
|
||||
def clean_database():
|
||||
return run_database_maintenance()
|
||||
|
||||
db_logger.info("✅ Database Suite Module initialisiert")
|
||||
db_logger.info("📊 FINALE ULTRA Konsolidierung: 8 Dateien → 1 Datei (87% Reduktion)")
|
||||
@ -1,425 +0,0 @@
|
||||
"""
|
||||
Erweiterte Datenbank-Utilities für Backup, Monitoring und Wartung.
|
||||
"""
|
||||
|
||||
import os
|
||||
import shutil
|
||||
import sqlite3
|
||||
import threading
|
||||
import time
|
||||
import gzip
|
||||
from datetime import datetime, timedelta
|
||||
from typing import Dict, List, Optional, Tuple
|
||||
from pathlib import Path
|
||||
|
||||
from sqlalchemy import text
|
||||
from sqlalchemy.engine import Engine
|
||||
|
||||
from utils.settings import DATABASE_PATH
|
||||
from utils.logging_config import get_logger
|
||||
from models import get_cached_session, create_optimized_engine
|
||||
|
||||
logger = get_logger("database")
|
||||
|
||||
# ===== BACKUP-SYSTEM =====
|
||||
|
||||
class DatabaseBackupManager:
|
||||
"""
|
||||
Verwaltet automatische Datenbank-Backups mit Rotation.
|
||||
"""
|
||||
|
||||
def __init__(self, backup_dir: str = None):
|
||||
self.backup_dir = backup_dir or os.path.join(os.path.dirname(DATABASE_PATH), "backups")
|
||||
self.ensure_backup_directory()
|
||||
self._backup_lock = threading.Lock()
|
||||
|
||||
def ensure_backup_directory(self):
|
||||
"""Stellt sicher, dass das Backup-Verzeichnis existiert."""
|
||||
Path(self.backup_dir).mkdir(parents=True, exist_ok=True)
|
||||
|
||||
def create_backup(self, compress: bool = True) -> str:
|
||||
"""
|
||||
Erstellt ein Backup der Datenbank.
|
||||
|
||||
Args:
|
||||
compress: Ob das Backup komprimiert werden soll
|
||||
|
||||
Returns:
|
||||
str: Pfad zum erstellten Backup
|
||||
"""
|
||||
with self._backup_lock:
|
||||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
backup_filename = f"myp_backup_{timestamp}.db"
|
||||
|
||||
if compress:
|
||||
backup_filename += ".gz"
|
||||
|
||||
backup_path = os.path.join(self.backup_dir, backup_filename)
|
||||
|
||||
try:
|
||||
if compress:
|
||||
# Komprimiertes Backup erstellen
|
||||
with open(DATABASE_PATH, 'rb') as f_in:
|
||||
with gzip.open(backup_path, 'wb') as f_out:
|
||||
shutil.copyfileobj(f_in, f_out)
|
||||
else:
|
||||
# Einfache Kopie
|
||||
shutil.copy2(DATABASE_PATH, backup_path)
|
||||
|
||||
logger.info(f"Datenbank-Backup erstellt: {backup_path}")
|
||||
return backup_path
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Erstellen des Backups: {str(e)}")
|
||||
raise
|
||||
|
||||
def restore_backup(self, backup_path: str) -> bool:
|
||||
"""
|
||||
Stellt ein Backup wieder her.
|
||||
|
||||
Args:
|
||||
backup_path: Pfad zum Backup
|
||||
|
||||
Returns:
|
||||
bool: True bei Erfolg
|
||||
"""
|
||||
with self._backup_lock:
|
||||
try:
|
||||
# Aktuelles Backup der bestehenden DB erstellen
|
||||
current_backup = self.create_backup()
|
||||
logger.info(f"Sicherheitsbackup erstellt: {current_backup}")
|
||||
|
||||
if backup_path.endswith('.gz'):
|
||||
# Komprimiertes Backup wiederherstellen
|
||||
with gzip.open(backup_path, 'rb') as f_in:
|
||||
with open(DATABASE_PATH, 'wb') as f_out:
|
||||
shutil.copyfileobj(f_in, f_out)
|
||||
else:
|
||||
# Einfache Kopie
|
||||
shutil.copy2(backup_path, DATABASE_PATH)
|
||||
|
||||
logger.info(f"Datenbank aus Backup wiederhergestellt: {backup_path}")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Wiederherstellen des Backups: {str(e)}")
|
||||
return False
|
||||
|
||||
def cleanup_old_backups(self, keep_days: int = 30):
|
||||
"""
|
||||
Löscht alte Backups.
|
||||
|
||||
Args:
|
||||
keep_days: Anzahl Tage, die Backups aufbewahrt werden sollen
|
||||
"""
|
||||
cutoff_date = datetime.now() - timedelta(days=keep_days)
|
||||
deleted_count = 0
|
||||
|
||||
try:
|
||||
for filename in os.listdir(self.backup_dir):
|
||||
if filename.startswith("myp_backup_"):
|
||||
file_path = os.path.join(self.backup_dir, filename)
|
||||
file_time = datetime.fromtimestamp(os.path.getctime(file_path))
|
||||
|
||||
if file_time < cutoff_date:
|
||||
os.remove(file_path)
|
||||
deleted_count += 1
|
||||
logger.info(f"Altes Backup gelöscht: {filename}")
|
||||
|
||||
if deleted_count > 0:
|
||||
logger.info(f"{deleted_count} alte Backups gelöscht")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Bereinigen alter Backups: {str(e)}")
|
||||
|
||||
def get_backup_list(self) -> List[Dict]:
|
||||
"""
|
||||
Gibt eine Liste aller verfügbaren Backups zurück.
|
||||
|
||||
Returns:
|
||||
List[Dict]: Liste mit Backup-Informationen
|
||||
"""
|
||||
backups = []
|
||||
|
||||
try:
|
||||
for filename in os.listdir(self.backup_dir):
|
||||
if filename.startswith("myp_backup_"):
|
||||
file_path = os.path.join(self.backup_dir, filename)
|
||||
file_stat = os.stat(file_path)
|
||||
|
||||
backups.append({
|
||||
"filename": filename,
|
||||
"path": file_path,
|
||||
"size": file_stat.st_size,
|
||||
"created": datetime.fromtimestamp(file_stat.st_ctime),
|
||||
"compressed": filename.endswith('.gz')
|
||||
})
|
||||
|
||||
# Nach Erstellungsdatum sortieren (neueste zuerst)
|
||||
backups.sort(key=lambda x: x['created'], reverse=True)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Abrufen der Backup-Liste: {str(e)}")
|
||||
|
||||
return backups
|
||||
|
||||
|
||||
# ===== DATENBANK-MONITORING =====
|
||||
|
||||
class DatabaseMonitor:
|
||||
"""
|
||||
Überwacht die Datenbank-Performance und -Gesundheit.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.engine = create_optimized_engine()
|
||||
|
||||
def get_database_stats(self) -> Dict:
|
||||
"""
|
||||
Sammelt Datenbank-Statistiken.
|
||||
|
||||
Returns:
|
||||
Dict: Datenbank-Statistiken
|
||||
"""
|
||||
stats = {}
|
||||
|
||||
try:
|
||||
with self.engine.connect() as conn:
|
||||
# Datenbankgröße
|
||||
result = conn.execute(text("SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()"))
|
||||
db_size = result.fetchone()[0]
|
||||
stats['database_size_bytes'] = db_size
|
||||
stats['database_size_mb'] = round(db_size / (1024 * 1024), 2)
|
||||
|
||||
# WAL-Datei-Größe
|
||||
wal_path = DATABASE_PATH + "-wal"
|
||||
if os.path.exists(wal_path):
|
||||
wal_size = os.path.getsize(wal_path)
|
||||
stats['wal_size_bytes'] = wal_size
|
||||
stats['wal_size_mb'] = round(wal_size / (1024 * 1024), 2)
|
||||
else:
|
||||
stats['wal_size_bytes'] = 0
|
||||
stats['wal_size_mb'] = 0
|
||||
|
||||
# Journal-Modus
|
||||
result = conn.execute(text("PRAGMA journal_mode"))
|
||||
stats['journal_mode'] = result.fetchone()[0]
|
||||
|
||||
# Cache-Statistiken
|
||||
result = conn.execute(text("PRAGMA cache_size"))
|
||||
stats['cache_size'] = result.fetchone()[0]
|
||||
|
||||
# Synchronous-Modus
|
||||
result = conn.execute(text("PRAGMA synchronous"))
|
||||
stats['synchronous_mode'] = result.fetchone()[0]
|
||||
|
||||
# Tabellen-Statistiken
|
||||
result = conn.execute(text("""
|
||||
SELECT name,
|
||||
(SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=m.name) as table_count
|
||||
FROM sqlite_master m WHERE type='table'
|
||||
"""))
|
||||
|
||||
table_stats = {}
|
||||
for table_name, _ in result.fetchall():
|
||||
if not table_name.startswith('sqlite_'):
|
||||
count_result = conn.execute(text(f"SELECT COUNT(*) FROM {table_name}"))
|
||||
table_stats[table_name] = count_result.fetchone()[0]
|
||||
|
||||
stats['table_counts'] = table_stats
|
||||
|
||||
# Letzte Wartung
|
||||
stats['last_analyze'] = self._get_last_analyze_time()
|
||||
stats['last_vacuum'] = self._get_last_vacuum_time()
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Sammeln der Datenbank-Statistiken: {str(e)}")
|
||||
stats['error'] = str(e)
|
||||
|
||||
return stats
|
||||
|
||||
def _get_last_analyze_time(self) -> Optional[str]:
|
||||
"""Ermittelt den Zeitpunkt der letzten ANALYZE-Operation."""
|
||||
try:
|
||||
# SQLite speichert keine direkten Timestamps für ANALYZE
|
||||
# Wir verwenden die Modifikationszeit der Statistik-Tabellen
|
||||
stat_path = DATABASE_PATH + "-stat"
|
||||
if os.path.exists(stat_path):
|
||||
return datetime.fromtimestamp(os.path.getmtime(stat_path)).isoformat()
|
||||
except:
|
||||
pass
|
||||
return None
|
||||
|
||||
def _get_last_vacuum_time(self) -> Optional[str]:
|
||||
"""Ermittelt den Zeitpunkt der letzten VACUUM-Operation."""
|
||||
try:
|
||||
# Approximation über Datei-Modifikationszeit
|
||||
return datetime.fromtimestamp(os.path.getmtime(DATABASE_PATH)).isoformat()
|
||||
except:
|
||||
pass
|
||||
return None
|
||||
|
||||
def check_database_health(self) -> Dict:
|
||||
"""
|
||||
Führt eine Gesundheitsprüfung der Datenbank durch.
|
||||
|
||||
Returns:
|
||||
Dict: Gesundheitsstatus
|
||||
"""
|
||||
health = {
|
||||
"status": "healthy",
|
||||
"issues": [],
|
||||
"recommendations": []
|
||||
}
|
||||
|
||||
try:
|
||||
with self.engine.connect() as conn:
|
||||
# Integritätsprüfung
|
||||
result = conn.execute(text("PRAGMA integrity_check"))
|
||||
integrity_result = result.fetchone()[0]
|
||||
|
||||
if integrity_result != "ok":
|
||||
health["status"] = "critical"
|
||||
health["issues"].append(f"Integritätsprüfung fehlgeschlagen: {integrity_result}")
|
||||
|
||||
# WAL-Dateigröße prüfen
|
||||
wal_path = DATABASE_PATH + "-wal"
|
||||
if os.path.exists(wal_path):
|
||||
wal_size_mb = os.path.getsize(wal_path) / (1024 * 1024)
|
||||
if wal_size_mb > 100: # Über 100MB
|
||||
health["issues"].append(f"WAL-Datei sehr groß: {wal_size_mb:.1f}MB")
|
||||
health["recommendations"].append("WAL-Checkpoint durchführen")
|
||||
|
||||
# Freier Speicherplatz prüfen
|
||||
db_dir = os.path.dirname(DATABASE_PATH)
|
||||
free_space = shutil.disk_usage(db_dir).free / (1024 * 1024 * 1024) # GB
|
||||
|
||||
if free_space < 1: # Weniger als 1GB
|
||||
health["status"] = "warning" if health["status"] == "healthy" else health["status"]
|
||||
health["issues"].append(f"Wenig freier Speicherplatz: {free_space:.1f}GB")
|
||||
health["recommendations"].append("Speicherplatz freigeben oder alte Backups löschen")
|
||||
|
||||
# Connection Pool Status (falls verfügbar)
|
||||
# Hier könnten weitere Checks hinzugefügt werden
|
||||
|
||||
except Exception as e:
|
||||
health["status"] = "error"
|
||||
health["issues"].append(f"Fehler bei Gesundheitsprüfung: {str(e)}")
|
||||
logger.error(f"Fehler bei Datenbank-Gesundheitsprüfung: {str(e)}")
|
||||
|
||||
return health
|
||||
|
||||
def optimize_database(self) -> Dict:
|
||||
"""
|
||||
Führt Optimierungsoperationen auf der Datenbank durch.
|
||||
|
||||
Returns:
|
||||
Dict: Ergebnis der Optimierung
|
||||
"""
|
||||
result = {
|
||||
"operations": [],
|
||||
"success": True,
|
||||
"errors": []
|
||||
}
|
||||
|
||||
try:
|
||||
with self.engine.connect() as conn:
|
||||
# ANALYZE für bessere Query-Planung
|
||||
conn.execute(text("ANALYZE"))
|
||||
result["operations"].append("ANALYZE ausgeführt")
|
||||
|
||||
# WAL-Checkpoint
|
||||
checkpoint_result = conn.execute(text("PRAGMA wal_checkpoint(TRUNCATE)"))
|
||||
checkpoint_info = checkpoint_result.fetchone()
|
||||
result["operations"].append(f"WAL-Checkpoint: {checkpoint_info}")
|
||||
|
||||
# Incremental Vacuum
|
||||
conn.execute(text("PRAGMA incremental_vacuum"))
|
||||
result["operations"].append("Incremental Vacuum ausgeführt")
|
||||
|
||||
# Optimize Pragma
|
||||
conn.execute(text("PRAGMA optimize"))
|
||||
result["operations"].append("PRAGMA optimize ausgeführt")
|
||||
|
||||
conn.commit()
|
||||
|
||||
except Exception as e:
|
||||
result["success"] = False
|
||||
result["errors"].append(str(e))
|
||||
logger.error(f"Fehler bei Datenbank-Optimierung: {str(e)}")
|
||||
|
||||
return result
|
||||
|
||||
|
||||
# ===== AUTOMATISCHE WARTUNG =====
|
||||
|
||||
class DatabaseMaintenanceScheduler:
|
||||
"""
|
||||
Plant und führt automatische Wartungsaufgaben durch.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self.backup_manager = DatabaseBackupManager()
|
||||
self.monitor = DatabaseMonitor()
|
||||
self._running = False
|
||||
self._thread = None
|
||||
|
||||
def start_maintenance_scheduler(self):
|
||||
"""Startet den Wartungs-Scheduler."""
|
||||
if self._running:
|
||||
return
|
||||
|
||||
self._running = True
|
||||
self._thread = threading.Thread(target=self._maintenance_loop, daemon=True)
|
||||
self._thread.start()
|
||||
logger.info("Datenbank-Wartungs-Scheduler gestartet")
|
||||
|
||||
def stop_maintenance_scheduler(self):
|
||||
"""Stoppt den Wartungs-Scheduler."""
|
||||
self._running = False
|
||||
if self._thread:
|
||||
self._thread.join(timeout=5)
|
||||
logger.info("Datenbank-Wartungs-Scheduler gestoppt")
|
||||
|
||||
def _maintenance_loop(self):
|
||||
"""Hauptschleife für Wartungsaufgaben."""
|
||||
last_backup = datetime.now()
|
||||
last_cleanup = datetime.now()
|
||||
last_optimization = datetime.now()
|
||||
|
||||
while self._running:
|
||||
try:
|
||||
now = datetime.now()
|
||||
|
||||
# Tägliches Backup (alle 24 Stunden)
|
||||
if (now - last_backup).total_seconds() > 86400: # 24 Stunden
|
||||
self.backup_manager.create_backup()
|
||||
last_backup = now
|
||||
|
||||
# Wöchentliche Bereinigung alter Backups (alle 7 Tage)
|
||||
if (now - last_cleanup).total_seconds() > 604800: # 7 Tage
|
||||
self.backup_manager.cleanup_old_backups()
|
||||
last_cleanup = now
|
||||
|
||||
# Tägliche Optimierung (alle 24 Stunden)
|
||||
if (now - last_optimization).total_seconds() > 86400: # 24 Stunden
|
||||
self.monitor.optimize_database()
|
||||
last_optimization = now
|
||||
|
||||
# 1 Stunde warten bis zum nächsten Check
|
||||
time.sleep(3600)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler im Wartungs-Scheduler: {str(e)}")
|
||||
time.sleep(300) # 5 Minuten warten bei Fehlern
|
||||
|
||||
|
||||
# ===== GLOBALE INSTANZEN =====
|
||||
|
||||
# Globale Instanzen für einfachen Zugriff
|
||||
backup_manager = DatabaseBackupManager()
|
||||
database_monitor = DatabaseMonitor()
|
||||
maintenance_scheduler = DatabaseMaintenanceScheduler()
|
||||
|
||||
# Automatisch starten
|
||||
maintenance_scheduler.start_maintenance_scheduler()
|
||||
@ -1,743 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
MYP Debug CLI
|
||||
Kommandozeilen-Tool für Diagnose und Debugging der MYP-Anwendung
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import argparse
|
||||
import time
|
||||
import json
|
||||
import importlib
|
||||
import logging
|
||||
import sqlite3
|
||||
from datetime import datetime
|
||||
import traceback
|
||||
from pprint import pprint
|
||||
|
||||
# Eigene Module importieren
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
# Farbige Ausgabe für die Konsole
|
||||
COLORS = {
|
||||
'RESET': '\033[0m',
|
||||
'BOLD': '\033[1m',
|
||||
'RED': '\033[31m',
|
||||
'GREEN': '\033[32m',
|
||||
'YELLOW': '\033[33m',
|
||||
'BLUE': '\033[34m',
|
||||
'MAGENTA': '\033[35m',
|
||||
'CYAN': '\033[36m',
|
||||
}
|
||||
|
||||
# Emojis für verschiedene Log-Level und Kategorien
|
||||
LOG_EMOJIS = {
|
||||
'DEBUG': '🔍',
|
||||
'INFO': 'ℹ️',
|
||||
'WARNING': '⚠️',
|
||||
'ERROR': '❌',
|
||||
'CRITICAL': '🔥',
|
||||
'SUCCESS': '✅',
|
||||
'DATABASE': '💾',
|
||||
'NETWORK': '🌐',
|
||||
'SYSTEM': '💻',
|
||||
'PRINTER': '🖨️',
|
||||
'API': '📡',
|
||||
'USER': '👤'
|
||||
}
|
||||
|
||||
# Prüfen, ob das Terminal Farben unterstützt
|
||||
def supports_color():
|
||||
"""Prüft, ob das Terminal Farben unterstützt."""
|
||||
if os.name == 'nt':
|
||||
try:
|
||||
import ctypes
|
||||
kernel32 = ctypes.windll.kernel32
|
||||
# Aktiviere VT100-Unterstützung unter Windows
|
||||
kernel32.SetConsoleMode(kernel32.GetStdHandle(-11), 7)
|
||||
return True
|
||||
except:
|
||||
return False
|
||||
else:
|
||||
return sys.stdout.isatty()
|
||||
|
||||
USE_COLOR = supports_color()
|
||||
|
||||
def colorize(text, color):
|
||||
"""Färbt den Text ein, wenn Farben unterstützt werden."""
|
||||
if USE_COLOR and color in COLORS:
|
||||
return f"{COLORS[color]}{text}{COLORS['RESET']}"
|
||||
return text
|
||||
|
||||
def print_success(message):
|
||||
print(f"{LOG_EMOJIS['SUCCESS']} {colorize(message, 'GREEN')}")
|
||||
|
||||
def print_error(message):
|
||||
print(f"{LOG_EMOJIS['ERROR']} {colorize(message, 'RED')}")
|
||||
|
||||
def print_warning(message):
|
||||
print(f"{LOG_EMOJIS['WARNING']} {colorize(message, 'YELLOW')}")
|
||||
|
||||
def print_info(message):
|
||||
print(f"{LOG_EMOJIS['INFO']} {colorize(message, 'BLUE')}")
|
||||
|
||||
def print_debug(message):
|
||||
print(f"{LOG_EMOJIS['DEBUG']} {colorize(message, 'CYAN')}")
|
||||
|
||||
def print_database(message):
|
||||
print(f"{LOG_EMOJIS['DATABASE']} {colorize(message, 'MAGENTA')}")
|
||||
|
||||
def print_network(message):
|
||||
print(f"{LOG_EMOJIS['NETWORK']} {colorize(message, 'CYAN')}")
|
||||
|
||||
def print_system(message):
|
||||
print(f"{LOG_EMOJIS['SYSTEM']} {colorize(message, 'BLUE')}")
|
||||
|
||||
def print_printer(message):
|
||||
print(f"{LOG_EMOJIS['PRINTER']} {colorize(message, 'GREEN')}")
|
||||
|
||||
def print_header(message):
|
||||
print(f"\n{colorize('='*80, 'BOLD')}")
|
||||
print(f"{colorize(message.center(80), 'BOLD')}")
|
||||
print(f"{colorize('='*80, 'BOLD')}\n")
|
||||
|
||||
def print_section(message):
|
||||
print(f"\n{colorize('-'*40, 'BOLD')}")
|
||||
print(f"{colorize(message, 'BOLD')}")
|
||||
print(f"{colorize('-'*40, 'BOLD')}\n")
|
||||
|
||||
# Hilfsfunktionen
|
||||
|
||||
def get_database_path():
|
||||
"""Gibt den Pfad zur Datenbank zurück."""
|
||||
try:
|
||||
from utils.settings import DATABASE_PATH
|
||||
return DATABASE_PATH
|
||||
except ImportError:
|
||||
# Fallback auf Standard-Pfad
|
||||
base_dir = os.path.dirname(os.path.abspath(__file__))
|
||||
return os.path.join(base_dir, "database", "myp.db")
|
||||
|
||||
def check_database():
|
||||
"""Prüft den Zustand der Datenbank."""
|
||||
db_path = get_database_path()
|
||||
|
||||
if not os.path.exists(db_path):
|
||||
print_error(f"Datenbank nicht gefunden: {db_path}")
|
||||
return False
|
||||
|
||||
try:
|
||||
conn = sqlite3.connect(db_path)
|
||||
cursor = conn.cursor()
|
||||
|
||||
# Tabellen auflisten
|
||||
cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
|
||||
tables = cursor.fetchall()
|
||||
|
||||
print_database(f"Datenbank gefunden: {db_path}")
|
||||
print_database(f"Größe: {os.path.getsize(db_path) / (1024*1024):.2f} MB")
|
||||
print_database(f"Tabellen ({len(tables)}):")
|
||||
|
||||
for table in tables:
|
||||
# Anzahl der Datensätze pro Tabelle
|
||||
cursor.execute(f"SELECT COUNT(*) FROM {table[0]}")
|
||||
count = cursor.fetchone()[0]
|
||||
print(f" 📋 {table[0]}: {count} Einträge")
|
||||
|
||||
conn.close()
|
||||
return True
|
||||
except sqlite3.Error as e:
|
||||
print_error(f"Datenbankfehler: {e}")
|
||||
return False
|
||||
except Exception as e:
|
||||
print_error(f"Fehler beim Prüfen der Datenbank: {e}")
|
||||
return False
|
||||
|
||||
def check_log_files():
|
||||
"""Prüft die Log-Dateien und zeigt die neuesten Einträge an."""
|
||||
try:
|
||||
from utils.settings import LOG_DIR, LOG_SUBDIRS
|
||||
|
||||
if not os.path.exists(LOG_DIR):
|
||||
print_error(f"Log-Verzeichnis nicht gefunden: {LOG_DIR}")
|
||||
return False
|
||||
|
||||
print_info(f"Log-Verzeichnis: {LOG_DIR}")
|
||||
|
||||
for subdir in LOG_SUBDIRS:
|
||||
log_path = os.path.join(LOG_DIR, subdir, f"{subdir}.log")
|
||||
|
||||
if not os.path.exists(log_path):
|
||||
print_warning(f"Log-Datei nicht gefunden: {log_path}")
|
||||
continue
|
||||
|
||||
size = os.path.getsize(log_path) / 1024 # KB
|
||||
print_info(f"Log-Datei: {subdir}.log ({size:.1f} KB)")
|
||||
|
||||
# Letzte Zeilen anzeigen
|
||||
try:
|
||||
with open(log_path, 'r') as f:
|
||||
lines = f.readlines()
|
||||
last_lines = lines[-5:] # Letzte 5 Zeilen
|
||||
|
||||
print(" Letzte Einträge:")
|
||||
for line in last_lines:
|
||||
line = line.strip()
|
||||
|
||||
# Farbliche Hervorhebung je nach Log-Level
|
||||
if "ERROR" in line:
|
||||
print(f" {colorize(line, 'RED')}")
|
||||
elif "WARNING" in line:
|
||||
print(f" {colorize(line, 'YELLOW')}")
|
||||
elif "INFO" in line:
|
||||
print(f" {colorize(line, 'GREEN')}")
|
||||
elif "DEBUG" in line:
|
||||
print(f" {colorize(line, 'CYAN')}")
|
||||
else:
|
||||
print(f" {line}")
|
||||
except Exception as e:
|
||||
print_warning(f" Fehler beim Lesen der Log-Datei: {e}")
|
||||
|
||||
return True
|
||||
except ImportError:
|
||||
print_error("Konfiguration für Logs nicht gefunden")
|
||||
return False
|
||||
except Exception as e:
|
||||
print_error(f"Fehler beim Prüfen der Log-Dateien: {e}")
|
||||
return False
|
||||
|
||||
def check_environment():
|
||||
"""Prüft die Umgebungsvariablen und System-Einstellungen."""
|
||||
print_info("Umgebungsinformationen:")
|
||||
print(f" Python-Version: {sys.version.split()[0]}")
|
||||
print(f" Betriebssystem: {os.name} - {sys.platform}")
|
||||
print(f" Arbeitsverzeichnis: {os.getcwd()}")
|
||||
|
||||
print_info("Wichtige Umgebungsvariablen:")
|
||||
env_vars = [
|
||||
"FLASK_ENV", "FLASK_DEBUG", "MYP_SSL_ENABLED",
|
||||
"MYP_SSL_HOSTNAME", "PYTHONPATH"
|
||||
]
|
||||
|
||||
for var in env_vars:
|
||||
value = os.environ.get(var, "nicht gesetzt")
|
||||
print(f" {var}: {value}")
|
||||
|
||||
try:
|
||||
# Flask-Konfiguration prüfen
|
||||
print_info("Flask-Konfiguration:")
|
||||
from utils.settings import FLASK_HOST, FLASK_PORT, FLASK_DEBUG, SSL_ENABLED
|
||||
|
||||
print(f" Host: {FLASK_HOST}")
|
||||
print(f" Port: {FLASK_PORT}")
|
||||
print(f" Debug-Modus: {FLASK_DEBUG}")
|
||||
print(f" SSL aktiviert: {SSL_ENABLED}")
|
||||
|
||||
# Module prüfen
|
||||
required_modules = [
|
||||
'flask', 'sqlalchemy', 'flask_login', 'werkzeug'
|
||||
]
|
||||
|
||||
print_info("Benötigte Module:")
|
||||
for module in required_modules:
|
||||
try:
|
||||
mod = importlib.import_module(module)
|
||||
version = getattr(mod, '__version__', 'unbekannt')
|
||||
print(f" {module}: {colorize('OK', 'GREEN')} (Version {version})")
|
||||
except ImportError:
|
||||
print(f" {module}: {colorize('FEHLT', 'RED')}")
|
||||
|
||||
except ImportError:
|
||||
print_warning("Flask-Konfiguration konnte nicht geladen werden")
|
||||
except Exception as e:
|
||||
print_error(f"Fehler beim Prüfen der Umgebung: {e}")
|
||||
|
||||
def scan_printer(ip_address, timeout=5):
|
||||
"""Scannt einen Drucker und zeigt Informationen an."""
|
||||
import socket
|
||||
|
||||
print_printer(f"Prüfe Drucker mit IP: {ip_address}")
|
||||
|
||||
# Ping testen
|
||||
import subprocess
|
||||
try:
|
||||
if os.name == 'nt': # Windows
|
||||
cmd = ['ping', '-n', '1', '-w', str(timeout * 1000), ip_address]
|
||||
else: # Unix/Linux/macOS
|
||||
cmd = ['ping', '-c', '1', '-W', str(timeout), ip_address]
|
||||
|
||||
print(f" 🏓 Ping-Test: ", end="")
|
||||
result = subprocess.run(cmd, capture_output=True, text=True,
|
||||
encoding='utf-8', errors='replace')
|
||||
|
||||
if result.returncode == 0:
|
||||
print(colorize("Erreichbar", "GREEN"))
|
||||
else:
|
||||
print(colorize("Nicht erreichbar", "RED"))
|
||||
print(f" 📄 Details: {result.stdout}")
|
||||
return
|
||||
except Exception as e:
|
||||
print(colorize(f"Fehler bei Ping-Test: {e}", "RED"))
|
||||
|
||||
# Offene Ports prüfen
|
||||
common_ports = [80, 443, 8080, 8443, 631, 9100, 9101, 9102]
|
||||
open_ports = []
|
||||
|
||||
print(" 🔍 Port-Scan: ", end="")
|
||||
for port in common_ports:
|
||||
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
sock.settimeout(timeout)
|
||||
result = sock.connect_ex((ip_address, port))
|
||||
if result == 0:
|
||||
open_ports.append(port)
|
||||
sock.close()
|
||||
|
||||
if open_ports:
|
||||
print(colorize(f"Offene Ports: {', '.join(map(str, open_ports))}", "GREEN"))
|
||||
else:
|
||||
print(colorize("Keine offenen Ports gefunden", "YELLOW"))
|
||||
|
||||
# Drucker-Info über Tapo-API testen (wenn vorhanden)
|
||||
try:
|
||||
from PyP100 import PyP110
|
||||
|
||||
print(" 🔌 Smart Plug Test: ", end="")
|
||||
try:
|
||||
# Standardmäßig Anmeldeinformationen aus der Konfiguration verwenden
|
||||
from utils.settings import TAPO_USERNAME, TAPO_PASSWORD
|
||||
|
||||
p110 = PyP110.P110(ip_address, TAPO_USERNAME, TAPO_PASSWORD)
|
||||
p110.handshake()
|
||||
p110.login()
|
||||
|
||||
device_info = p110.getDeviceInfo()
|
||||
print(colorize("Verbunden", "GREEN"))
|
||||
print(f" 📛 Gerätename: {device_info.get('nickname', 'Unbekannt')}")
|
||||
print(f" ⚡ Status: {'Ein' if device_info.get('device_on', False) else 'Aus'}")
|
||||
|
||||
if 'on_time' in device_info:
|
||||
on_time = device_info['on_time']
|
||||
print(f" ⏱️ Betriebszeit: {on_time // 60} Minuten, {on_time % 60} Sekunden")
|
||||
|
||||
except Exception as e:
|
||||
print(colorize(f"Fehler: {e}", "RED"))
|
||||
except ImportError:
|
||||
print_warning(" PyP100-Modul nicht verfügbar - Smart Plug Test übersprungen")
|
||||
|
||||
def check_printers_from_db():
|
||||
"""Prüft die in der Datenbank gespeicherten Drucker."""
|
||||
db_path = get_database_path()
|
||||
|
||||
if not os.path.exists(db_path):
|
||||
print_error(f"Datenbank nicht gefunden: {db_path}")
|
||||
return
|
||||
|
||||
try:
|
||||
conn = sqlite3.connect(db_path)
|
||||
conn.row_factory = sqlite3.Row
|
||||
cursor = conn.cursor()
|
||||
|
||||
# Drucker-Tabelle prüfen
|
||||
cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='printer';")
|
||||
if not cursor.fetchone():
|
||||
print_error("Drucker-Tabelle nicht gefunden")
|
||||
conn.close()
|
||||
return
|
||||
|
||||
# Drucker auslesen
|
||||
cursor.execute("SELECT * FROM printer;")
|
||||
printers = cursor.fetchall()
|
||||
|
||||
if not printers:
|
||||
print_warning("Keine Drucker in der Datenbank gefunden")
|
||||
conn.close()
|
||||
return
|
||||
|
||||
print_info(f"{len(printers)} Drucker gefunden:")
|
||||
|
||||
for printer in printers:
|
||||
status_color = 'GREEN' if printer['status'] == 'online' else 'RED'
|
||||
print(f" {printer['name']}: {colorize(printer['status'], status_color)}")
|
||||
print(f" IP: {printer['ip_address']}")
|
||||
print(f" Plug IP: {printer['plug_ip'] or 'Nicht konfiguriert'}")
|
||||
|
||||
# Detaillierteren Status prüfen
|
||||
if printer['plug_ip']:
|
||||
ask = input(f" Möchten Sie den Drucker {printer['name']} scannen? (j/n): ")
|
||||
if ask.lower() in ('j', 'ja', 'y', 'yes'):
|
||||
scan_printer(printer['plug_ip'])
|
||||
|
||||
conn.close()
|
||||
except Exception as e:
|
||||
print_error(f"Fehler beim Prüfen der Drucker: {e}")
|
||||
traceback.print_exc()
|
||||
|
||||
def check_flask_routes():
|
||||
"""Zeigt alle verfügbaren Flask-Routen an."""
|
||||
try:
|
||||
# Versuche, die Flask-App zu importieren
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
try:
|
||||
from app import app as flask_app
|
||||
except ImportError:
|
||||
print_error("Flask-App konnte nicht importiert werden")
|
||||
return
|
||||
|
||||
# Alle Routen auflisten
|
||||
print_info("Verfügbare Flask-Routen:")
|
||||
|
||||
routes = []
|
||||
for rule in flask_app.url_map.iter_rules():
|
||||
routes.append({
|
||||
'endpoint': rule.endpoint,
|
||||
'methods': ', '.join(sorted(rule.methods - {'HEAD', 'OPTIONS'})),
|
||||
'path': rule.rule
|
||||
})
|
||||
|
||||
# Nach Pfad sortieren
|
||||
routes = sorted(routes, key=lambda x: x['path'])
|
||||
|
||||
# Routen anzeigen
|
||||
for route in routes:
|
||||
method_color = 'GREEN' if 'GET' in route['methods'] else 'BLUE'
|
||||
print(f" {colorize(route['methods'], method_color)} {route['path']}")
|
||||
print(f" → {route['endpoint']}")
|
||||
|
||||
print_info(f"Insgesamt {len(routes)} Routen gefunden")
|
||||
|
||||
except Exception as e:
|
||||
print_error(f"Fehler beim Abrufen der Flask-Routen: {e}")
|
||||
traceback.print_exc()
|
||||
|
||||
def print_system_info():
|
||||
"""Zeigt detaillierte Systeminformationen an."""
|
||||
print_header("Systeminformationen")
|
||||
|
||||
print_section("Basisinformationen")
|
||||
import platform
|
||||
print(f"Python-Version: {platform.python_version()}")
|
||||
print(f"Betriebssystem: {platform.system()} {platform.release()}")
|
||||
print(f"Architektur: {platform.machine()}")
|
||||
print(f"Prozessor: {platform.processor()}")
|
||||
|
||||
print_section("Speicher")
|
||||
try:
|
||||
import psutil
|
||||
vm = psutil.virtual_memory()
|
||||
print(f"Gesamter Speicher: {vm.total / (1024**3):.1f} GB")
|
||||
print(f"Verfügbarer Speicher: {vm.available / (1024**3):.1f} GB")
|
||||
print(f"Speicherauslastung: {vm.percent}%")
|
||||
|
||||
disk = psutil.disk_usage('/')
|
||||
print(f"Festplatte gesamt: {disk.total / (1024**3):.1f} GB")
|
||||
print(f"Festplatte frei: {disk.free / (1024**3):.1f} GB")
|
||||
print(f"Festplattenauslastung: {disk.percent}%")
|
||||
except ImportError:
|
||||
print_warning("psutil-Modul nicht verfügbar - eingeschränkte Informationen")
|
||||
|
||||
print_section("Netzwerk")
|
||||
try:
|
||||
import socket
|
||||
hostname = socket.gethostname()
|
||||
ip_address = socket.gethostbyname(hostname)
|
||||
print(f"Hostname: {hostname}")
|
||||
print(f"IP-Adresse: {ip_address}")
|
||||
|
||||
# Netzwerkschnittstellen
|
||||
if 'psutil' in sys.modules:
|
||||
print("Netzwerkschnittstellen:")
|
||||
for name, addrs in psutil.net_if_addrs().items():
|
||||
for addr in addrs:
|
||||
if addr.family == socket.AF_INET:
|
||||
print(f" {name}: {addr.address}")
|
||||
except Exception as e:
|
||||
print_warning(f"Fehler beim Abrufen der Netzwerkinformationen: {e}")
|
||||
|
||||
def test_logging_system():
|
||||
"""Testet das verbesserte Logging-System mit allen Features."""
|
||||
print_header("Logging-System Test")
|
||||
|
||||
try:
|
||||
# Versuche die neuen Logging-Funktionen zu importieren
|
||||
from utils.logging_config import get_logger, debug_request, debug_response, measure_execution_time
|
||||
|
||||
print_success("Neue Logging-Module erfolgreich importiert")
|
||||
|
||||
# Test verschiedener Logger
|
||||
test_loggers = ['app', 'auth', 'jobs', 'printers', 'errors']
|
||||
|
||||
print_section("Logger-Tests")
|
||||
for logger_name in test_loggers:
|
||||
try:
|
||||
logger = get_logger(logger_name)
|
||||
|
||||
# Test verschiedener Log-Level
|
||||
logger.debug(f"🔍 Debug-Test für {logger_name}")
|
||||
logger.info(f"ℹ️ Info-Test für {logger_name}")
|
||||
logger.warning(f"⚠️ Warning-Test für {logger_name}")
|
||||
|
||||
print_success(f"Logger '{logger_name}' funktioniert korrekt")
|
||||
except Exception as e:
|
||||
print_error(f"Fehler beim Testen von Logger '{logger_name}': {e}")
|
||||
|
||||
# Test Performance-Monitoring
|
||||
print_section("Performance-Monitoring Test")
|
||||
|
||||
@measure_execution_time(logger=get_logger("app"), task_name="Test-Funktion")
|
||||
def test_function():
|
||||
"""Eine Test-Funktion für das Performance-Monitoring."""
|
||||
import time
|
||||
time.sleep(0.1) # Simuliere etwas Arbeit
|
||||
return "Test erfolgreich"
|
||||
|
||||
result = test_function()
|
||||
print_success(f"Performance-Monitoring Test: {result}")
|
||||
|
||||
# Test der Debug-Utilities
|
||||
print_section("Debug-Utilities Test")
|
||||
|
||||
try:
|
||||
from utils.debug_utils import debug_dump, debug_trace, memory_usage
|
||||
|
||||
# Test debug_dump
|
||||
test_data = {
|
||||
"version": "1.0.0",
|
||||
"features": ["emojis", "colors", "performance-monitoring"],
|
||||
"status": "active"
|
||||
}
|
||||
debug_dump(test_data, "Test-Konfiguration")
|
||||
|
||||
# Test memory_usage
|
||||
memory_info = memory_usage()
|
||||
print_system(f"Aktueller Speicherverbrauch: {memory_info['rss']:.2f} MB")
|
||||
|
||||
print_success("Debug-Utilities funktionieren korrekt")
|
||||
|
||||
except ImportError as e:
|
||||
print_warning(f"Debug-Utilities nicht verfügbar: {e}")
|
||||
|
||||
# Zusammenfassung
|
||||
print_section("Test-Zusammenfassung")
|
||||
print_success("🎉 Alle Logging-System-Tests erfolgreich abgeschlossen!")
|
||||
print_info("Features verfügbar:")
|
||||
print(" ✅ Farbige Log-Ausgaben mit ANSI-Codes")
|
||||
print(" ✅ Emoji-Integration für bessere Lesbarkeit")
|
||||
print(" ✅ HTTP-Request/Response-Logging")
|
||||
print(" ✅ Performance-Monitoring mit Ausführungszeit")
|
||||
print(" ✅ Cross-Platform-Unterstützung (Windows/Unix)")
|
||||
print(" ✅ Strukturierte Debug-Informationen")
|
||||
|
||||
except ImportError as e:
|
||||
print_error(f"Logging-Module nicht verfügbar: {e}")
|
||||
print_warning("Stelle sicher, dass alle Module korrekt installiert sind")
|
||||
except Exception as e:
|
||||
print_error(f"Unerwarteter Fehler beim Logging-Test: {e}")
|
||||
traceback.print_exc()
|
||||
|
||||
# Hauptfunktionen für die Befehlszeile
|
||||
|
||||
def diagnose():
|
||||
"""Führt eine umfassende Diagnose durch."""
|
||||
print_header("MYP Diagnose-Tool")
|
||||
|
||||
print_section("Systemprüfung")
|
||||
check_environment()
|
||||
|
||||
print_section("Datenbankprüfung")
|
||||
check_database()
|
||||
|
||||
print_section("Log-Dateien")
|
||||
check_log_files()
|
||||
|
||||
print_success("Diagnose abgeschlossen!")
|
||||
|
||||
def scan_printers():
|
||||
"""Scannt und prüft alle Drucker."""
|
||||
print_header("Drucker-Scanner")
|
||||
|
||||
# Direkter Scan einer IP-Adresse
|
||||
ip = input("IP-Adresse zum Scannen (leer lassen, um Drucker aus der Datenbank zu prüfen): ")
|
||||
|
||||
if ip:
|
||||
scan_printer(ip)
|
||||
else:
|
||||
check_printers_from_db()
|
||||
|
||||
def show_routes():
|
||||
"""Zeigt alle verfügbaren API-Routen an."""
|
||||
print_header("API-Routen")
|
||||
check_flask_routes()
|
||||
|
||||
def system_info():
|
||||
"""Zeigt detaillierte Systeminformationen an."""
|
||||
print_system_info()
|
||||
|
||||
def show_logs():
|
||||
"""Zeigt und analysiert Log-Dateien."""
|
||||
print_header("Log-Analyse")
|
||||
|
||||
try:
|
||||
from utils.settings import LOG_DIR, LOG_SUBDIRS
|
||||
|
||||
if not os.path.exists(LOG_DIR):
|
||||
print_error(f"Log-Verzeichnis nicht gefunden: {LOG_DIR}")
|
||||
return
|
||||
|
||||
print_info(f"Log-Verzeichnis: {LOG_DIR}")
|
||||
print_info("Verfügbare Logs:")
|
||||
|
||||
for i, subdir in enumerate(LOG_SUBDIRS, 1):
|
||||
log_path = os.path.join(LOG_DIR, subdir, f"{subdir}.log")
|
||||
size = "Nicht gefunden"
|
||||
|
||||
if os.path.exists(log_path):
|
||||
size = f"{os.path.getsize(log_path) / 1024:.1f} KB"
|
||||
|
||||
print(f" {i}. {subdir}.log ({size})")
|
||||
|
||||
choice = input("\nWelches Log möchten Sie anzeigen? (Nummer oder Name): ")
|
||||
|
||||
# Nummer in Namen umwandeln
|
||||
try:
|
||||
choice_num = int(choice) - 1
|
||||
if 0 <= choice_num < len(LOG_SUBDIRS):
|
||||
choice = LOG_SUBDIRS[choice_num]
|
||||
except ValueError:
|
||||
pass
|
||||
|
||||
# Prüfen, ob die Wahl gültig ist
|
||||
if choice not in LOG_SUBDIRS:
|
||||
print_error(f"Ungültige Auswahl: {choice}")
|
||||
return
|
||||
|
||||
log_path = os.path.join(LOG_DIR, choice, f"{choice}.log")
|
||||
|
||||
if not os.path.exists(log_path):
|
||||
print_error(f"Log-Datei nicht gefunden: {log_path}")
|
||||
return
|
||||
|
||||
# Anzahl der anzuzeigenden Zeilen
|
||||
lines_count = input("Anzahl der anzuzeigenden Zeilen (Standard: 20): ")
|
||||
lines_count = int(lines_count) if lines_count.isdigit() else 20
|
||||
|
||||
# Filter für bestimmte Log-Level
|
||||
level_filter = input("Nach Log-Level filtern (INFO, WARNING, ERROR oder leer für alle): ").upper()
|
||||
|
||||
# Log-Datei anzeigen
|
||||
with open(log_path, 'r') as f:
|
||||
lines = f.readlines()
|
||||
|
||||
# Filtern nach Log-Level
|
||||
if level_filter:
|
||||
lines = [line for line in lines if level_filter in line]
|
||||
|
||||
# Letzte n Zeilen auswählen
|
||||
lines = lines[-lines_count:]
|
||||
|
||||
print_section(f"Log-Datei: {choice}.log (letzte {len(lines)} Einträge)")
|
||||
|
||||
for line in lines:
|
||||
line = line.strip()
|
||||
|
||||
# Farbliche Hervorhebung je nach Log-Level
|
||||
if "ERROR" in line:
|
||||
print(colorize(line, 'RED'))
|
||||
elif "WARNING" in line:
|
||||
print(colorize(line, 'YELLOW'))
|
||||
elif "INFO" in line:
|
||||
print(colorize(line, 'GREEN'))
|
||||
elif "DEBUG" in line:
|
||||
print(colorize(line, 'CYAN'))
|
||||
else:
|
||||
print(line)
|
||||
|
||||
except ImportError:
|
||||
print_error("Konfiguration für Logs nicht gefunden")
|
||||
except Exception as e:
|
||||
print_error(f"Fehler beim Anzeigen der Log-Dateien: {e}")
|
||||
traceback.print_exc()
|
||||
|
||||
def parse_args():
|
||||
"""Parse command line arguments."""
|
||||
parser = argparse.ArgumentParser(description="MYP Debug CLI")
|
||||
|
||||
subparsers = parser.add_subparsers(dest="command", help="Befehl")
|
||||
|
||||
# Diagnose
|
||||
diag_parser = subparsers.add_parser("diagnose", help="Führt eine umfassende Diagnose durch")
|
||||
|
||||
# Drucker scannen
|
||||
scan_parser = subparsers.add_parser("scan", help="Scannt und prüft alle Drucker")
|
||||
|
||||
# Routen anzeigen
|
||||
routes_parser = subparsers.add_parser("routes", help="Zeigt alle verfügbaren API-Routen an")
|
||||
|
||||
# Systeminformationen
|
||||
sysinfo_parser = subparsers.add_parser("sysinfo", help="Zeigt detaillierte Systeminformationen an")
|
||||
|
||||
# Logs anzeigen
|
||||
logs_parser = subparsers.add_parser("logs", help="Zeigt und analysiert Log-Dateien")
|
||||
|
||||
# Logging-System testen
|
||||
logging_test_parser = subparsers.add_parser("test-logging", help="Testet das verbesserte Logging-System")
|
||||
|
||||
return parser.parse_args()
|
||||
|
||||
def main():
|
||||
"""Hauptfunktion."""
|
||||
args = parse_args()
|
||||
|
||||
if args.command == "diagnose":
|
||||
diagnose()
|
||||
elif args.command == "scan":
|
||||
scan_printers()
|
||||
elif args.command == "routes":
|
||||
show_routes()
|
||||
elif args.command == "sysinfo":
|
||||
system_info()
|
||||
elif args.command == "logs":
|
||||
show_logs()
|
||||
elif args.command == "test-logging":
|
||||
test_logging_system()
|
||||
else:
|
||||
# Interaktives Menü, wenn kein Befehl angegeben wurde
|
||||
print_header("MYP Debug CLI")
|
||||
print("Wählen Sie eine Option:")
|
||||
print(" 1. Diagnose durchführen")
|
||||
print(" 2. Drucker scannen")
|
||||
print(" 3. API-Routen anzeigen")
|
||||
print(" 4. Systeminformationen anzeigen")
|
||||
print(" 5. Log-Dateien anzeigen")
|
||||
print(" 6. Logging-System testen")
|
||||
print(" 0. Beenden")
|
||||
|
||||
choice = input("\nIhre Wahl: ")
|
||||
|
||||
if choice == "1":
|
||||
diagnose()
|
||||
elif choice == "2":
|
||||
scan_printers()
|
||||
elif choice == "3":
|
||||
show_routes()
|
||||
elif choice == "4":
|
||||
system_info()
|
||||
elif choice == "5":
|
||||
show_logs()
|
||||
elif choice == "6":
|
||||
test_logging_system()
|
||||
elif choice == "0":
|
||||
print("Auf Wiedersehen!")
|
||||
sys.exit(0)
|
||||
else:
|
||||
print_error("Ungültige Auswahl")
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
main()
|
||||
except KeyboardInterrupt:
|
||||
print_info("\nProgramm wurde durch Benutzer abgebrochen")
|
||||
except Exception as e:
|
||||
print_error(f"Unerwarteter Fehler: {e}")
|
||||
traceback.print_exc()
|
||||
@ -1,437 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
|
||||
"""
|
||||
Debug-Skript für Druckererkennung
|
||||
Testet die Druckererkennung und identifiziert Probleme
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
import requests
|
||||
import json
|
||||
import time
|
||||
import threading
|
||||
from datetime import datetime
|
||||
import sqlite3
|
||||
import subprocess
|
||||
import platform
|
||||
|
||||
# Füge das Anwendungsverzeichnis zum Python-Pfad hinzu
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
def log_message(message, level="INFO"):
|
||||
"""Logge eine Nachricht mit Zeitstempel"""
|
||||
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
|
||||
print(f"[{timestamp}] [{level}] {message}")
|
||||
|
||||
def test_database_connection():
|
||||
"""Teste die Datenbankverbindung"""
|
||||
log_message("Teste Datenbankverbindung...")
|
||||
|
||||
try:
|
||||
# Pfad zur App hinzufügen für korrekten Import
|
||||
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
|
||||
|
||||
try:
|
||||
from utils.settings import DATABASE_PATH
|
||||
db_file = DATABASE_PATH
|
||||
except ImportError:
|
||||
# Fallback für lokale Ausführung
|
||||
db_file = os.path.join('database', 'myp.db')
|
||||
|
||||
if os.path.exists(db_file):
|
||||
log_message(f"Gefundene Datenbankdatei: {db_file}")
|
||||
|
||||
conn = sqlite3.connect(db_file)
|
||||
cursor = conn.cursor()
|
||||
|
||||
# Prüfe ob Printers-Tabelle existiert
|
||||
cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='printers';")
|
||||
if cursor.fetchone():
|
||||
log_message("✅ Printers-Tabelle gefunden")
|
||||
|
||||
# Zähle Drucker
|
||||
cursor.execute("SELECT COUNT(*) FROM printers;")
|
||||
count = cursor.fetchone()[0]
|
||||
log_message(f"📊 Anzahl Drucker in Datenbank: {count}")
|
||||
|
||||
# Zeige Drucker-Details
|
||||
cursor.execute("SELECT id, name, plug_ip, status FROM printers;")
|
||||
printers = cursor.fetchall()
|
||||
|
||||
for printer in printers:
|
||||
log_message(f" Drucker {printer[0]}: {printer[1]} ({printer[2]}) - Status: {printer[3]}")
|
||||
|
||||
conn.close()
|
||||
return True
|
||||
else:
|
||||
log_message("❌ Printers-Tabelle nicht gefunden")
|
||||
conn.close()
|
||||
else:
|
||||
log_message(f"❌ Datenbankdatei nicht gefunden: {db_file}")
|
||||
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
log_message(f"❌ Datenbankfehler: {str(e)}", "ERROR")
|
||||
return False
|
||||
|
||||
def test_api_endpoints():
|
||||
"""Teste die API-Endpunkte"""
|
||||
log_message("Teste API-Endpunkte...")
|
||||
|
||||
base_url = "http://localhost:5000"
|
||||
endpoints = [
|
||||
"/api/printers",
|
||||
"/api/printers/status"
|
||||
]
|
||||
|
||||
for endpoint in endpoints:
|
||||
try:
|
||||
log_message(f"Teste {endpoint}...")
|
||||
|
||||
response = requests.get(f"{base_url}{endpoint}", timeout=10)
|
||||
|
||||
log_message(f" Status Code: {response.status_code}")
|
||||
|
||||
if response.status_code == 200:
|
||||
try:
|
||||
data = response.json()
|
||||
if endpoint == "/api/printers":
|
||||
if 'printers' in data:
|
||||
log_message(f" ✅ {len(data['printers'])} Drucker geladen")
|
||||
else:
|
||||
log_message(f" ⚠️ Unerwartete Antwortstruktur: {list(data.keys())}")
|
||||
else:
|
||||
if isinstance(data, list):
|
||||
log_message(f" ✅ {len(data)} Drucker mit Status geladen")
|
||||
else:
|
||||
log_message(f" ⚠️ Unerwartete Antwortstruktur: {type(data)}")
|
||||
except json.JSONDecodeError:
|
||||
log_message(f" ❌ Ungültige JSON-Antwort", "ERROR")
|
||||
else:
|
||||
log_message(f" ❌ HTTP-Fehler: {response.status_code}", "ERROR")
|
||||
try:
|
||||
error_data = response.json()
|
||||
log_message(f" Fehlermeldung: {error_data.get('error', 'Unbekannt')}", "ERROR")
|
||||
except:
|
||||
log_message(f" Antwort: {response.text[:200]}", "ERROR")
|
||||
|
||||
except requests.exceptions.ConnectionError:
|
||||
log_message(f" ❌ Verbindung zu {base_url} fehlgeschlagen", "ERROR")
|
||||
log_message(" Ist die Flask-Anwendung gestartet?", "ERROR")
|
||||
except requests.exceptions.Timeout:
|
||||
log_message(f" ❌ Timeout bei {endpoint}", "ERROR")
|
||||
except Exception as e:
|
||||
log_message(f" ❌ Fehler: {str(e)}", "ERROR")
|
||||
|
||||
def test_network_connectivity():
|
||||
"""Teste Netzwerkverbindung zu Druckern"""
|
||||
log_message("Teste Netzwerkverbindung zu Druckern...")
|
||||
|
||||
# Lade Drucker aus Datenbank
|
||||
try:
|
||||
# Verwende konfigurierten Datenbankpfad
|
||||
try:
|
||||
from utils.settings import DATABASE_PATH
|
||||
db_file = DATABASE_PATH
|
||||
except ImportError:
|
||||
db_file = os.path.join('database', 'myp.db')
|
||||
|
||||
printers = []
|
||||
|
||||
if os.path.exists(db_file):
|
||||
conn = sqlite3.connect(db_file)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("SELECT name, plug_ip FROM printers WHERE plug_ip IS NOT NULL;")
|
||||
printers = cursor.fetchall()
|
||||
conn.close()
|
||||
|
||||
if not printers:
|
||||
log_message("❌ Keine Drucker mit IP-Adressen gefunden")
|
||||
return
|
||||
|
||||
for name, ip in printers:
|
||||
log_message(f"Teste Verbindung zu {name} ({ip})...")
|
||||
|
||||
# Ping-Test
|
||||
try:
|
||||
if platform.system().lower() == "windows":
|
||||
result = subprocess.run(['ping', '-n', '1', '-w', '3000', ip],
|
||||
capture_output=True, text=True, timeout=5,
|
||||
encoding='utf-8', errors='replace')
|
||||
else:
|
||||
result = subprocess.run(['ping', '-c', '1', '-W', '3', ip],
|
||||
capture_output=True, text=True, timeout=5,
|
||||
encoding='utf-8', errors='replace')
|
||||
|
||||
if result.returncode == 0:
|
||||
log_message(f" ✅ Ping erfolgreich")
|
||||
else:
|
||||
log_message(f" ❌ Ping fehlgeschlagen")
|
||||
|
||||
except subprocess.TimeoutExpired:
|
||||
log_message(f" ❌ Ping-Timeout")
|
||||
except Exception as e:
|
||||
log_message(f" ❌ Ping-Fehler: {str(e)}")
|
||||
|
||||
# HTTP-Test (falls Drucker Webinterface hat)
|
||||
try:
|
||||
response = requests.get(f"http://{ip}", timeout=3)
|
||||
log_message(f" ✅ HTTP-Verbindung erfolgreich (Status: {response.status_code})")
|
||||
except requests.exceptions.Timeout:
|
||||
log_message(f" ⚠️ HTTP-Timeout (normal für Drucker ohne Webinterface)")
|
||||
except requests.exceptions.ConnectionError:
|
||||
log_message(f" ⚠️ HTTP-Verbindung fehlgeschlagen (normal für Drucker ohne Webinterface)")
|
||||
except Exception as e:
|
||||
log_message(f" ⚠️ HTTP-Fehler: {str(e)}")
|
||||
|
||||
except Exception as e:
|
||||
log_message(f"❌ Fehler beim Testen der Netzwerkverbindung: {str(e)}", "ERROR")
|
||||
|
||||
def test_tapo_connections():
|
||||
"""Teste TP-Link Tapo P110-Steckdosen-Verbindungen"""
|
||||
log_message("Teste TP-Link Tapo P110-Steckdosen-Verbindungen...")
|
||||
|
||||
try:
|
||||
# PyP100 importieren
|
||||
from PyP100 import PyP110
|
||||
log_message("✅ PyP100-Modul erfolgreich importiert")
|
||||
except ImportError:
|
||||
log_message("❌ PyP100-Modul nicht verfügbar", "ERROR")
|
||||
log_message(" Installiere mit: pip install PyP100", "INFO")
|
||||
return
|
||||
|
||||
# Lade Drucker aus Datenbank
|
||||
try:
|
||||
# Verwende konfigurierten Datenbankpfad
|
||||
try:
|
||||
from utils.settings import DATABASE_PATH
|
||||
db_file = DATABASE_PATH
|
||||
except ImportError:
|
||||
db_file = os.path.join('database', 'myp.db')
|
||||
|
||||
printers = []
|
||||
|
||||
if os.path.exists(db_file):
|
||||
conn = sqlite3.connect(db_file)
|
||||
cursor = conn.cursor()
|
||||
cursor.execute("SELECT id, name, plug_ip, plug_username, plug_password FROM printers WHERE plug_ip IS NOT NULL;")
|
||||
printers = cursor.fetchall()
|
||||
conn.close()
|
||||
|
||||
if not printers:
|
||||
log_message("❌ Keine Drucker mit Tapo-Konfiguration gefunden")
|
||||
return
|
||||
|
||||
successful_connections = 0
|
||||
total_printers = len(printers)
|
||||
|
||||
for printer_id, name, plug_ip, plug_username, plug_password in printers:
|
||||
log_message(f"Teste Tapo-Verbindung zu {name} ({plug_ip})...")
|
||||
|
||||
# Konfiguration validieren
|
||||
if not all([plug_ip, plug_username, plug_password]):
|
||||
log_message(f" ❌ Unvollständige Konfiguration")
|
||||
missing = []
|
||||
if not plug_ip: missing.append("IP-Adresse")
|
||||
if not plug_username: missing.append("Benutzername")
|
||||
if not plug_password: missing.append("Passwort")
|
||||
log_message(f" Fehlend: {', '.join(missing)}")
|
||||
continue
|
||||
|
||||
try:
|
||||
# Tapo-Verbindung herstellen
|
||||
p110 = PyP110.P110(plug_ip, plug_username, plug_password)
|
||||
p110.handshake() # Authentifizierung
|
||||
p110.login() # Login
|
||||
|
||||
# Geräteinformationen abrufen
|
||||
device_info = p110.getDeviceInfo()
|
||||
|
||||
log_message(f" ✅ Tapo-Verbindung erfolgreich")
|
||||
log_message(f" 📛 Gerätename: {device_info.get('nickname', 'Unbekannt')}")
|
||||
log_message(f" ⚡ Status: {'Ein' if device_info.get('device_on', False) else 'Aus'}")
|
||||
|
||||
if 'on_time' in device_info:
|
||||
on_time = device_info.get('on_time', 0)
|
||||
hours, minutes = divmod(on_time // 60, 60)
|
||||
log_message(f" ⏱️ Betriebszeit: {hours}h {minutes}m")
|
||||
|
||||
if 'power_usage' in device_info:
|
||||
power_usage = device_info.get('power_usage', {})
|
||||
current_power = power_usage.get('power_mw', 0) / 1000 # mW zu W
|
||||
log_message(f" 🔋 Aktueller Verbrauch: {current_power:.1f}W")
|
||||
|
||||
successful_connections += 1
|
||||
|
||||
except Exception as e:
|
||||
log_message(f" ❌ Tapo-Verbindung fehlgeschlagen: {str(e)}")
|
||||
|
||||
# Detaillierte Fehleranalyse
|
||||
if "login" in str(e).lower():
|
||||
log_message(f" 🔐 Mögliche Ursache: Falsche Anmeldedaten")
|
||||
elif "timeout" in str(e).lower():
|
||||
log_message(f" ⏱️ Mögliche Ursache: Netzwerk-Timeout")
|
||||
elif "connect" in str(e).lower():
|
||||
log_message(f" 🌐 Mögliche Ursache: Steckdose nicht erreichbar")
|
||||
elif "handshake" in str(e).lower():
|
||||
log_message(f" 🤝 Mögliche Ursache: Protokoll-Handshake fehlgeschlagen")
|
||||
|
||||
# Zusammenfassung
|
||||
success_rate = (successful_connections / total_printers * 100) if total_printers > 0 else 0
|
||||
log_message(f"📊 Tapo-Verbindungs-Zusammenfassung:")
|
||||
log_message(f" Getestete Drucker: {total_printers}")
|
||||
log_message(f" Erfolgreiche Verbindungen: {successful_connections}")
|
||||
log_message(f" Erfolgsrate: {success_rate:.1f}%")
|
||||
|
||||
if successful_connections == total_printers:
|
||||
log_message("🎉 Alle Tapo-Verbindungen erfolgreich!")
|
||||
elif successful_connections > 0:
|
||||
log_message("⚠️ Einige Tapo-Verbindungen fehlgeschlagen")
|
||||
else:
|
||||
log_message("❌ Keine Tapo-Verbindungen erfolgreich", "ERROR")
|
||||
|
||||
except Exception as e:
|
||||
log_message(f"❌ Fehler beim Testen der Tapo-Verbindungen: {str(e)}", "ERROR")
|
||||
|
||||
def test_flask_app_status():
|
||||
"""Teste den Status der Flask-Anwendung"""
|
||||
log_message("Teste Flask-Anwendung...")
|
||||
|
||||
try:
|
||||
# Teste Hauptseite
|
||||
response = requests.get("http://localhost:5000", timeout=5)
|
||||
if response.status_code == 200:
|
||||
log_message("✅ Flask-Anwendung läuft")
|
||||
else:
|
||||
log_message(f"⚠️ Flask-Anwendung antwortet mit Status {response.status_code}")
|
||||
|
||||
except requests.exceptions.ConnectionError:
|
||||
log_message("❌ Flask-Anwendung nicht erreichbar", "ERROR")
|
||||
log_message(" Starte die Anwendung mit: python app.py", "INFO")
|
||||
except Exception as e:
|
||||
log_message(f"❌ Fehler beim Testen der Flask-Anwendung: {str(e)}", "ERROR")
|
||||
|
||||
def test_threading_timeout():
|
||||
"""Teste die Threading-basierte Timeout-Implementierung"""
|
||||
log_message("Teste Threading-Timeout-Implementierung...")
|
||||
|
||||
def test_function():
|
||||
"""Simuliere eine langsame Datenbankabfrage"""
|
||||
time.sleep(2)
|
||||
return "Erfolgreich"
|
||||
|
||||
try:
|
||||
result = None
|
||||
timeout_occurred = False
|
||||
|
||||
def run_test():
|
||||
nonlocal result, timeout_occurred
|
||||
try:
|
||||
result = test_function()
|
||||
except Exception as e:
|
||||
log_message(f"Fehler in Test-Thread: {str(e)}", "ERROR")
|
||||
timeout_occurred = True
|
||||
|
||||
# Starte Test in separatem Thread
|
||||
thread = threading.Thread(target=run_test)
|
||||
thread.daemon = True
|
||||
thread.start()
|
||||
thread.join(timeout=3) # 3 Sekunden Timeout
|
||||
|
||||
if thread.is_alive() or timeout_occurred or result is None:
|
||||
log_message("❌ Threading-Timeout-Test fehlgeschlagen", "ERROR")
|
||||
else:
|
||||
log_message("✅ Threading-Timeout-Implementierung funktioniert")
|
||||
|
||||
except Exception as e:
|
||||
log_message(f"❌ Fehler beim Threading-Test: {str(e)}", "ERROR")
|
||||
|
||||
def check_system_requirements():
|
||||
"""Prüfe Systemanforderungen"""
|
||||
log_message("Prüfe Systemanforderungen...")
|
||||
|
||||
# Python-Version
|
||||
python_version = sys.version_info
|
||||
log_message(f"Python-Version: {python_version.major}.{python_version.minor}.{python_version.micro}")
|
||||
|
||||
if python_version.major >= 3 and python_version.minor >= 7:
|
||||
log_message("✅ Python-Version ist kompatibel")
|
||||
else:
|
||||
log_message("❌ Python 3.7+ erforderlich", "ERROR")
|
||||
|
||||
# Erforderliche Module
|
||||
required_modules = ['flask', 'requests', 'sqlite3', 'threading']
|
||||
|
||||
for module in required_modules:
|
||||
try:
|
||||
__import__(module)
|
||||
log_message(f"✅ Modul {module} verfügbar")
|
||||
except ImportError:
|
||||
log_message(f"❌ Modul {module} nicht verfügbar", "ERROR")
|
||||
|
||||
# Betriebssystem
|
||||
os_name = platform.system()
|
||||
log_message(f"Betriebssystem: {os_name}")
|
||||
|
||||
if os_name == "Windows":
|
||||
log_message("✅ Windows-spezifische Fixes wurden angewendet")
|
||||
else:
|
||||
log_message("ℹ️ Unix-basiertes System erkannt")
|
||||
|
||||
def run_comprehensive_test():
|
||||
"""Führe alle Tests aus"""
|
||||
log_message("=== MYP Druckerverwaltung - Diagnose-Tool ===")
|
||||
log_message("Starte umfassende Systemdiagnose...")
|
||||
print()
|
||||
|
||||
# Systemanforderungen prüfen
|
||||
check_system_requirements()
|
||||
print()
|
||||
|
||||
# Threading-Test
|
||||
test_threading_timeout()
|
||||
print()
|
||||
|
||||
# Datenbanktest
|
||||
test_database_connection()
|
||||
print()
|
||||
|
||||
# Flask-App-Test
|
||||
test_flask_app_status()
|
||||
print()
|
||||
|
||||
# API-Tests
|
||||
test_api_endpoints()
|
||||
print()
|
||||
|
||||
# Netzwerk-Tests
|
||||
test_network_connectivity()
|
||||
print()
|
||||
|
||||
# Tapo-Verbindungen testen
|
||||
test_tapo_connections()
|
||||
print()
|
||||
|
||||
log_message("=== Diagnose abgeschlossen ===")
|
||||
print()
|
||||
|
||||
# Empfehlungen
|
||||
log_message("📋 Empfehlungen:")
|
||||
log_message("1. Stelle sicher, dass die Flask-Anwendung läuft: python app.py")
|
||||
log_message("2. Prüfe die Datenbankverbindung und Drucker-Konfiguration")
|
||||
log_message("3. Teste die Netzwerkverbindung zu den Druckern")
|
||||
log_message("4. Bei Windows: Threading-basierte Timeouts wurden implementiert")
|
||||
log_message("5. Überprüfe die Logs in logs/app/ für weitere Details")
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
run_comprehensive_test()
|
||||
except KeyboardInterrupt:
|
||||
log_message("Diagnose durch Benutzer abgebrochen", "INFO")
|
||||
except Exception as e:
|
||||
log_message(f"Unerwarteter Fehler: {str(e)}", "ERROR")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
@ -1,80 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Debug-Script für Gastanträge und Admin-Berechtigungen
|
||||
"""
|
||||
|
||||
from models import get_cached_session, GuestRequest, User, UserPermission
|
||||
from flask_login import current_user
|
||||
|
||||
def check_guest_requests():
|
||||
"""Prüfe Gastanträge nach Status"""
|
||||
print("=== GASTANTRÄGE STATUS ===")
|
||||
|
||||
with get_cached_session() as db:
|
||||
pending = db.query(GuestRequest).filter_by(status='pending').count()
|
||||
approved = db.query(GuestRequest).filter_by(status='approved').count()
|
||||
rejected = db.query(GuestRequest).filter_by(status='rejected').count()
|
||||
total = db.query(GuestRequest).count()
|
||||
|
||||
print(f"Gesamt: {total}")
|
||||
print(f"Pending (Wird geprüft): {pending}")
|
||||
print(f"Approved (Genehmigt): {approved}")
|
||||
print(f"Rejected (Abgelehnt): {rejected}")
|
||||
|
||||
if pending == 0:
|
||||
print("\n⚠️ PROBLEM: Keine Anträge mit Status 'pending' gefunden!")
|
||||
print(" → Die Genehmigen/Ablehnen-Buttons werden nur bei Status 'pending' angezeigt")
|
||||
|
||||
# Erstelle einen Test-Antrag
|
||||
print("\n🔧 Erstelle Test-Gastantrag...")
|
||||
test_request = GuestRequest(
|
||||
name="Test Admin",
|
||||
email="admin@test.de",
|
||||
reason="Test für Admin-Buttons",
|
||||
duration_min=30,
|
||||
status="pending"
|
||||
)
|
||||
db.add(test_request)
|
||||
db.commit()
|
||||
print(f"✅ Test-Antrag erstellt (ID: {test_request.id})")
|
||||
else:
|
||||
print(f"\n✅ {pending} Anträge mit Status 'pending' gefunden")
|
||||
|
||||
# Zeige pending Anträge
|
||||
pending_requests = db.query(GuestRequest).filter_by(status='pending').all()
|
||||
for req in pending_requests:
|
||||
print(f" ID {req.id}: {req.name} - {req.email}")
|
||||
|
||||
def check_admin_users():
|
||||
"""Prüfe Admin-Benutzer und Berechtigungen"""
|
||||
print("\n=== ADMIN-BENUTZER ===")
|
||||
|
||||
with get_cached_session() as db:
|
||||
# Alle Admins
|
||||
admins = db.query(User).filter_by(is_admin=True).all()
|
||||
print(f"Admin-Benutzer: {len(admins)}")
|
||||
for admin in admins:
|
||||
print(f" {admin.username} (ID: {admin.id}) - Email: {admin.email}")
|
||||
|
||||
# Benutzer mit can_approve_jobs
|
||||
users_with_approval = db.query(User).join(UserPermission).filter(
|
||||
UserPermission.can_approve_jobs == True
|
||||
).all()
|
||||
print(f"\nBenutzer mit can_approve_jobs: {len(users_with_approval)}")
|
||||
for user in users_with_approval:
|
||||
print(f" {user.username} (ID: {user.id}) - Email: {user.email}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
try:
|
||||
check_guest_requests()
|
||||
check_admin_users()
|
||||
print("\n=== LÖSUNG ===")
|
||||
print("1. Gehen Sie zu: http://127.0.0.1:5000/requests/overview")
|
||||
print("2. Öffnen Sie die Browser-Konsole (F12)")
|
||||
print("3. Suchen Sie nach 'Admin-Berechtigungen:' in der Konsole")
|
||||
print("4. Die Buttons sollten bei Anträgen mit Status 'pending' erscheinen")
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Fehler: {e}")
|
||||
import traceback
|
||||
traceback.print_exc()
|
||||
@ -1,199 +0,0 @@
|
||||
#!/usr/bin/env python3.11
|
||||
"""
|
||||
Debug-Script für Login-Probleme
|
||||
Prüft Admin-Benutzer und Passwort-Hashing
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime
|
||||
|
||||
# Path für imports setzen
|
||||
sys.path.append(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
from models import get_db_session, User, create_initial_admin
|
||||
import bcrypt
|
||||
|
||||
def debug_admin_user():
|
||||
"""Prüft den Admin-Benutzer in der Datenbank"""
|
||||
print("=== DEBUG: Admin-Benutzer Analyse ===")
|
||||
|
||||
try:
|
||||
db_session = get_db_session()
|
||||
|
||||
# Alle Benutzer anzeigen
|
||||
users = db_session.query(User).all()
|
||||
print(f"\n📊 Gefundene Benutzer: {len(users)}")
|
||||
|
||||
for user in users:
|
||||
print(f"\n👤 Benutzer ID: {user.id}")
|
||||
print(f" Email: {user.email}")
|
||||
print(f" Username: {user.username}")
|
||||
print(f" Name: {user.name}")
|
||||
print(f" Role: {user.role}")
|
||||
print(f" Is Admin: {user.is_admin}")
|
||||
print(f" Active: {user.active}")
|
||||
print(f" Password Hash: {user.password_hash[:20]}...")
|
||||
print(f" Created: {user.created_at}")
|
||||
|
||||
# Admin-Benutzer spezifisch prüfen
|
||||
admin_email = "admin@mercedes-benz.com"
|
||||
admin_username = "admin"
|
||||
|
||||
print(f"\n🔍 Suche nach Admin-Benutzer:")
|
||||
print(f" Email: {admin_email}")
|
||||
print(f" Username: {admin_username}")
|
||||
|
||||
# Suche nach E-Mail
|
||||
admin_by_email = db_session.query(User).filter(User.email == admin_email).first()
|
||||
if admin_by_email:
|
||||
print(f"✅ Admin gefunden per E-Mail: {admin_by_email.email}")
|
||||
else:
|
||||
print(f"❌ Kein Admin mit E-Mail {admin_email} gefunden")
|
||||
|
||||
# Suche nach Username
|
||||
admin_by_username = db_session.query(User).filter(User.username == admin_username).first()
|
||||
if admin_by_username:
|
||||
print(f"✅ Admin gefunden per Username: {admin_by_username.username}")
|
||||
else:
|
||||
print(f"❌ Kein Admin mit Username {admin_username} gefunden")
|
||||
|
||||
db_session.close()
|
||||
|
||||
return admin_by_email or admin_by_username
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Fehler beim Datenbankzugriff: {str(e)}")
|
||||
return None
|
||||
|
||||
def test_password_verification(user, test_password="744563017196A"):
|
||||
"""Testet die Passwort-Verifikation"""
|
||||
print(f"\n=== DEBUG: Passwort-Test ===")
|
||||
print(f"Test-Passwort: {test_password}")
|
||||
|
||||
if not user:
|
||||
print("❌ Kein Benutzer für Passwort-Test vorhanden")
|
||||
return False
|
||||
|
||||
try:
|
||||
# Manueller bcrypt-Test
|
||||
password_bytes = test_password.encode('utf-8')
|
||||
hash_bytes = user.password_hash.encode('utf-8')
|
||||
|
||||
print(f"Password Bytes: {password_bytes}")
|
||||
print(f"Hash (first 50 chars): {user.password_hash[:50]}")
|
||||
|
||||
# Test mit bcrypt
|
||||
is_valid_bcrypt = bcrypt.checkpw(password_bytes, hash_bytes)
|
||||
print(f"✅ bcrypt.checkpw() Ergebnis: {is_valid_bcrypt}")
|
||||
|
||||
# Test mit User-Methode
|
||||
is_valid_user_method = user.check_password(test_password)
|
||||
print(f"✅ user.check_password() Ergebnis: {is_valid_user_method}")
|
||||
|
||||
return is_valid_bcrypt and is_valid_user_method
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Fehler beim Passwort-Test: {str(e)}")
|
||||
return False
|
||||
|
||||
def recreate_admin():
|
||||
"""Erstellt den Admin-Benutzer neu"""
|
||||
print(f"\n=== DEBUG: Admin-Benutzer neu erstellen ===")
|
||||
|
||||
try:
|
||||
success = create_initial_admin(
|
||||
email="admin@mercedes-benz.com",
|
||||
password="744563017196A",
|
||||
name="System Administrator",
|
||||
username="admin"
|
||||
)
|
||||
|
||||
if success:
|
||||
print("✅ Admin-Benutzer erfolgreich erstellt/aktualisiert")
|
||||
else:
|
||||
print("❌ Fehler beim Erstellen des Admin-Benutzers")
|
||||
|
||||
return success
|
||||
|
||||
except Exception as e:
|
||||
print(f"❌ Fehler beim Erstellen des Admins: {str(e)}")
|
||||
return False
|
||||
|
||||
def test_login_credentials():
|
||||
"""Testet verschiedene Login-Kombinationen"""
|
||||
print(f"\n=== DEBUG: Login-Kombinationen testen ===")
|
||||
|
||||
test_combinations = [
|
||||
("admin@mercedes-benz.com", "744563017196A"),
|
||||
("admin", "744563017196A"),
|
||||
]
|
||||
|
||||
db_session = get_db_session()
|
||||
|
||||
for email_or_username, password in test_combinations:
|
||||
print(f"\n🔍 Teste: {email_or_username} / {password}")
|
||||
|
||||
# Simuliere Login-Logic aus app.py
|
||||
user = db_session.query(User).filter(
|
||||
(User.username == email_or_username) | (User.email == email_or_username)
|
||||
).first()
|
||||
|
||||
if user:
|
||||
print(f"✅ Benutzer gefunden: {user.email} ({user.username})")
|
||||
|
||||
if user.check_password(password):
|
||||
print(f"✅ Passwort korrekt!")
|
||||
print(f"✅ Login wäre erfolgreich für: {user.email}")
|
||||
else:
|
||||
print(f"❌ Passwort falsch!")
|
||||
else:
|
||||
print(f"❌ Kein Benutzer mit {email_or_username} gefunden")
|
||||
|
||||
db_session.close()
|
||||
|
||||
def check_rate_limiting():
|
||||
"""Prüft Rate Limiting Status"""
|
||||
print(f"\n=== DEBUG: Rate Limiting Status ===")
|
||||
|
||||
# Simuliere localStorage-Werte (die wären normalerweise im Browser)
|
||||
# In einer echten Anwendung würden diese aus der Datenbank oder einem Cache kommen
|
||||
print("ℹ️ Rate Limiting wird client-seitig im localStorage verwaltet")
|
||||
print("ℹ️ Überprüfen Sie Ihren Browser-localStorage:")
|
||||
print(" - loginAttempts: sollte < 5 sein")
|
||||
print(" - lastAttemptTime: Zeit des letzten Versuchs")
|
||||
print("\n💡 Tipp: Öffnen Sie Entwicklertools > Application > Local Storage")
|
||||
print(" und löschen Sie 'loginAttempts' und 'lastAttemptTime' Einträge")
|
||||
|
||||
if __name__ == "__main__":
|
||||
print("🚀 MYP Login Debug-Tool gestartet")
|
||||
print("=" * 50)
|
||||
|
||||
# 1. Admin-Benutzer prüfen
|
||||
admin_user = debug_admin_user()
|
||||
|
||||
# 2. Passwort-Verifikation testen
|
||||
if admin_user:
|
||||
test_password_verification(admin_user)
|
||||
|
||||
# 3. Admin neu erstellen falls Probleme
|
||||
if not admin_user:
|
||||
print("\n⚠️ Kein Admin gefunden - erstelle neuen Admin...")
|
||||
recreate_admin()
|
||||
admin_user = debug_admin_user()
|
||||
if admin_user:
|
||||
test_password_verification(admin_user)
|
||||
|
||||
# 4. Login-Kombinationen testen
|
||||
test_login_credentials()
|
||||
|
||||
# 5. Rate Limiting prüfen
|
||||
check_rate_limiting()
|
||||
|
||||
print("\n" + "=" * 50)
|
||||
print("🎯 Debug abgeschlossen!")
|
||||
print("\n💡 Lösungsvorschläge:")
|
||||
print("1. Verwenden Sie admin@mercedes-benz.com + 744563017196A")
|
||||
print("2. Oder verwenden Sie admin + 744563017196A")
|
||||
print("3. Löschen Sie Rate-Limiting im Browser localStorage")
|
||||
print("4. Prüfen Sie die Browser-Konsole auf JavaScript-Fehler")
|
||||
@ -1,392 +0,0 @@
|
||||
"""
|
||||
Debug-Utilities für die MYP-Anwendung
|
||||
Hilft bei der Diagnose und Behebung von Problemen in der Anwendung
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
import json
|
||||
import traceback
|
||||
import inspect
|
||||
from datetime import datetime
|
||||
from functools import wraps
|
||||
import logging
|
||||
from typing import Any, Dict, List, Optional, Tuple, Union, Callable
|
||||
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
# Logger für dieses Modul erstellen
|
||||
debug_logger = get_logger("app")
|
||||
|
||||
# Konstanten für Formatierung
|
||||
DEBUG_SEPARATOR = "=" * 60
|
||||
DEBUG_SUBSEPARATOR = "-" * 60
|
||||
|
||||
class DebugLevel:
|
||||
"""Enum für Debug-Level"""
|
||||
MINIMAL = 0 # Nur kritische Fehler
|
||||
NORMAL = 1 # Standardfehler und wichtige Informationen
|
||||
VERBOSE = 2 # Ausführliche Informationen
|
||||
TRACE = 3 # Vollständige Trace-Informationen
|
||||
|
||||
# Aktuelles Debug-Level (kann zur Laufzeit geändert werden)
|
||||
CURRENT_DEBUG_LEVEL = DebugLevel.NORMAL
|
||||
|
||||
def set_debug_level(level: int):
|
||||
"""Setzt das aktuelle Debug-Level für die Anwendung"""
|
||||
global CURRENT_DEBUG_LEVEL
|
||||
CURRENT_DEBUG_LEVEL = level
|
||||
debug_logger.info(f"🔧 Debug-Level gesetzt auf: {level}")
|
||||
|
||||
def debug_print(message: str, level: int = DebugLevel.NORMAL):
|
||||
"""
|
||||
Gibt eine Debug-Nachricht aus, wenn das aktuelle Debug-Level mindestens dem angegebenen entspricht.
|
||||
|
||||
Args:
|
||||
message: Die auszugebende Nachricht
|
||||
level: Das erforderliche Debug-Level
|
||||
"""
|
||||
if level <= CURRENT_DEBUG_LEVEL:
|
||||
# Aktuelle Funktion und Zeilennummer ermitteln
|
||||
frame = inspect.currentframe().f_back
|
||||
func_name = frame.f_code.co_name
|
||||
file_name = os.path.basename(frame.f_code.co_filename)
|
||||
line_no = frame.f_lineno
|
||||
|
||||
# Debug-Ausgabe formatieren
|
||||
timestamp = datetime.now().strftime('%H:%M:%S.%f')[:-3]
|
||||
debug_prefix = f"[DEBUG {timestamp} {file_name}:{func_name}:{line_no}]"
|
||||
|
||||
# Verschiedene Levels mit unterschiedlichen Emojis markieren
|
||||
level_emoji = "🐞" if level >= DebugLevel.VERBOSE else "🔍"
|
||||
|
||||
# Ausgabe
|
||||
print(f"{level_emoji} {debug_prefix} {message}")
|
||||
|
||||
def debug_dump(obj: Any, name: str = "Object", level: int = DebugLevel.VERBOSE):
|
||||
"""
|
||||
Gibt den Inhalt eines Objekts für Debug-Zwecke aus.
|
||||
|
||||
Args:
|
||||
obj: Das zu untersuchende Objekt
|
||||
name: Name des Objekts für die Ausgabe
|
||||
level: Das erforderliche Debug-Level
|
||||
"""
|
||||
if level > CURRENT_DEBUG_LEVEL:
|
||||
return
|
||||
|
||||
debug_print(f"📦 Debug-Dump von {name}:", level)
|
||||
|
||||
try:
|
||||
# Für dict-ähnliche Objekte
|
||||
if hasattr(obj, 'items'):
|
||||
for k, v in obj.items():
|
||||
debug_print(f" {k}: {v}", level)
|
||||
# Für list/tuple-ähnliche Objekte
|
||||
elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes)):
|
||||
for i, item in enumerate(obj):
|
||||
debug_print(f" [{i}]: {item}", level)
|
||||
# Für einfache Objekte
|
||||
else:
|
||||
# Versuche als JSON zu formatieren
|
||||
try:
|
||||
json_str = json.dumps(obj, indent=2, default=str)
|
||||
debug_print(f" {json_str}", level)
|
||||
except:
|
||||
# Fallback auf einfache String-Darstellung
|
||||
debug_print(f" {obj}", level)
|
||||
except Exception as e:
|
||||
debug_print(f" Fehler beim Dump: {e}", level)
|
||||
|
||||
def debug_trace(message: str = "Execution trace"):
|
||||
"""
|
||||
Gibt einen vollständigen Stack-Trace für Debug-Zwecke aus.
|
||||
|
||||
Args:
|
||||
message: Begleitende Nachricht für den Trace
|
||||
"""
|
||||
if CURRENT_DEBUG_LEVEL < DebugLevel.TRACE:
|
||||
return
|
||||
|
||||
debug_print(f"🔬 TRACE: {message}", DebugLevel.TRACE)
|
||||
debug_print(DEBUG_SUBSEPARATOR, DebugLevel.TRACE)
|
||||
|
||||
# Stack-Trace sammeln
|
||||
stack = traceback.extract_stack()
|
||||
# Letzten Frame (diese Funktion) entfernen
|
||||
stack = stack[:-1]
|
||||
|
||||
for frame in stack:
|
||||
file_name = os.path.basename(frame.filename)
|
||||
debug_print(f" {file_name}:{frame.lineno} - {frame.name}", DebugLevel.TRACE)
|
||||
|
||||
debug_print(DEBUG_SUBSEPARATOR, DebugLevel.TRACE)
|
||||
|
||||
def debug_function(func=None, level: int = DebugLevel.NORMAL):
|
||||
"""
|
||||
Dekorator, der Eingang und Ausgang einer Funktion sowie die Ausführungszeit loggt.
|
||||
|
||||
Args:
|
||||
func: Die zu dekorierende Funktion
|
||||
level: Das erforderliche Debug-Level
|
||||
|
||||
Returns:
|
||||
Dekorierte Funktion
|
||||
"""
|
||||
def decorator(fn):
|
||||
@wraps(fn)
|
||||
def wrapper(*args, **kwargs):
|
||||
if CURRENT_DEBUG_LEVEL < level:
|
||||
return fn(*args, **kwargs)
|
||||
|
||||
# Funktionsaufruf loggen
|
||||
arg_str = ", ".join([
|
||||
*[str(arg) for arg in args],
|
||||
*[f"{k}={v}" for k, v in kwargs.items()]
|
||||
])
|
||||
if len(arg_str) > 100:
|
||||
arg_str = arg_str[:97] + "..."
|
||||
|
||||
debug_print(f"▶️ Starte {fn.__name__}({arg_str})", level)
|
||||
|
||||
# Ausführungszeit messen
|
||||
start_time = time.time()
|
||||
|
||||
try:
|
||||
# Funktion ausführen
|
||||
result = fn(*args, **kwargs)
|
||||
|
||||
# Ausführungszeit und Ergebnis loggen
|
||||
end_time = time.time()
|
||||
duration = (end_time - start_time) * 1000
|
||||
|
||||
result_str = str(result)
|
||||
if len(result_str) > 100:
|
||||
result_str = result_str[:97] + "..."
|
||||
|
||||
duration_emoji = "⏱️" if duration < 1000 else "⏳"
|
||||
debug_print(f"{duration_emoji} {fn.__name__} beendet in {duration:.2f} ms", level)
|
||||
debug_print(f"📤 Ergebnis: {result_str}", level)
|
||||
|
||||
return result
|
||||
except Exception as e:
|
||||
# Fehler loggen
|
||||
end_time = time.time()
|
||||
duration = (end_time - start_time) * 1000
|
||||
|
||||
debug_print(f"❌ {fn.__name__} fehlgeschlagen nach {duration:.2f} ms: {str(e)}", level)
|
||||
|
||||
# Stack-Trace nur bei hohem Debug-Level
|
||||
if CURRENT_DEBUG_LEVEL >= DebugLevel.VERBOSE:
|
||||
debug_print(f"🔬 Stack-Trace für {fn.__name__}:", DebugLevel.VERBOSE)
|
||||
traceback_str = traceback.format_exc()
|
||||
for line in traceback_str.split('\n'):
|
||||
debug_print(f" {line}", DebugLevel.VERBOSE)
|
||||
|
||||
# Exception weiterleiten
|
||||
raise
|
||||
|
||||
return wrapper
|
||||
|
||||
if func:
|
||||
return decorator(func)
|
||||
return decorator
|
||||
|
||||
def debug_timer(name: str = None, level: int = DebugLevel.NORMAL):
|
||||
"""
|
||||
Kontext-Manager, der die Ausführungszeit eines Code-Blocks misst.
|
||||
|
||||
Args:
|
||||
name: Name des Code-Blocks für die Ausgabe
|
||||
level: Das erforderliche Debug-Level
|
||||
|
||||
Beispiel:
|
||||
with debug_timer("Datenbankabfrage"):
|
||||
result = db.execute_query()
|
||||
"""
|
||||
class Timer:
|
||||
def __init__(self, block_name, debug_level):
|
||||
self.block_name = block_name
|
||||
self.debug_level = debug_level
|
||||
self.start_time = None
|
||||
|
||||
def __enter__(self):
|
||||
if CURRENT_DEBUG_LEVEL >= self.debug_level:
|
||||
self.start_time = time.time()
|
||||
block_name = self.block_name or "Code-Block"
|
||||
debug_print(f"⏱️ Starte Timer für: {block_name}", self.debug_level)
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||||
if CURRENT_DEBUG_LEVEL >= self.debug_level and self.start_time:
|
||||
end_time = time.time()
|
||||
duration = (end_time - self.start_time) * 1000
|
||||
block_name = self.block_name or "Code-Block"
|
||||
|
||||
if exc_type:
|
||||
debug_print(f"❌ {block_name} fehlgeschlagen nach {duration:.2f} ms: {exc_val}", self.debug_level)
|
||||
else:
|
||||
duration_emoji = "⏱️" if duration < 1000 else "⏳"
|
||||
debug_print(f"{duration_emoji} {block_name} beendet in {duration:.2f} ms", self.debug_level)
|
||||
|
||||
return Timer(name, level)
|
||||
|
||||
def debug_exception_handler(logger: Optional[logging.Logger] = None):
|
||||
"""
|
||||
Dekorator, der Ausnahmen abfängt und Details loggt.
|
||||
|
||||
Args:
|
||||
logger: Logger-Instanz für die Protokollierung (optional)
|
||||
|
||||
Returns:
|
||||
Dekorierte Funktion
|
||||
"""
|
||||
def decorator(func):
|
||||
@wraps(func)
|
||||
def wrapper(*args, **kwargs):
|
||||
try:
|
||||
return func(*args, **kwargs)
|
||||
except Exception as e:
|
||||
# Logger verwenden oder Fallback auf Standardausgabe
|
||||
log = logger or debug_logger
|
||||
|
||||
# Ausnahmedetails loggen
|
||||
log.error(f"❌ Ausnahme in {func.__name__}: {str(e)}")
|
||||
|
||||
# Stack-Trace bei hohem Debug-Level
|
||||
if CURRENT_DEBUG_LEVEL >= DebugLevel.VERBOSE:
|
||||
log.error("🔬 Stack-Trace:")
|
||||
traceback_str = traceback.format_exc()
|
||||
for line in traceback_str.split('\n'):
|
||||
if line.strip():
|
||||
log.error(f" {line}")
|
||||
|
||||
# Ausnahme weiterleiten
|
||||
raise
|
||||
|
||||
return wrapper
|
||||
|
||||
return decorator
|
||||
|
||||
# Konsolen-Befehle für interaktives Debugging
|
||||
|
||||
def dump_all_loggers():
|
||||
"""Gibt Informationen über alle konfigurierten Logger aus."""
|
||||
import logging
|
||||
|
||||
debug_print("📋 Konfigurierte Logger:", DebugLevel.VERBOSE)
|
||||
for name, logger in logging.Logger.manager.loggerDict.items():
|
||||
if isinstance(logger, logging.Logger):
|
||||
level_name = logging.getLevelName(logger.level)
|
||||
handlers = len(logger.handlers)
|
||||
debug_print(f" {name}: Level={level_name}, Handlers={handlers}", DebugLevel.VERBOSE)
|
||||
|
||||
def dump_environment():
|
||||
"""Gibt Umgebungsvariablen und Systeminformationen aus."""
|
||||
debug_print("🌐 Umgebungsinformationen:", DebugLevel.VERBOSE)
|
||||
debug_print(f" Python: {sys.version}", DebugLevel.VERBOSE)
|
||||
debug_print(f" Plattform: {sys.platform}", DebugLevel.VERBOSE)
|
||||
debug_print(f" Arbeitsverzeichnis: {os.getcwd()}", DebugLevel.VERBOSE)
|
||||
|
||||
debug_print("🔑 Umgebungsvariablen:", DebugLevel.VERBOSE)
|
||||
for key, value in sorted(os.environ.items()):
|
||||
# Passwörter und Secrets ausblenden
|
||||
if any(secret_key in key.lower() for secret_key in ['key', 'pass', 'secret', 'token', 'pwd']):
|
||||
value = "********"
|
||||
debug_print(f" {key}={value}", DebugLevel.VERBOSE)
|
||||
|
||||
def memory_usage(obj: Any = None) -> Dict[str, Any]:
|
||||
"""
|
||||
Gibt Informationen über den Speicherverbrauch zurück.
|
||||
|
||||
Args:
|
||||
obj: Optional ein Objekt, dessen Größe gemessen werden soll
|
||||
|
||||
Returns:
|
||||
Dict mit Speicherverbrauchsinformationen
|
||||
"""
|
||||
import psutil
|
||||
import sys
|
||||
|
||||
process = psutil.Process(os.getpid())
|
||||
memory_info = process.memory_info()
|
||||
|
||||
result = {
|
||||
"rss": memory_info.rss / (1024 * 1024), # MB
|
||||
"vms": memory_info.vms / (1024 * 1024), # MB
|
||||
"percent": process.memory_percent(),
|
||||
}
|
||||
|
||||
if obj is not None:
|
||||
try:
|
||||
import sys
|
||||
result["object_size"] = sys.getsizeof(obj) / 1024 # KB
|
||||
except:
|
||||
result["object_size"] = "Nicht messbar"
|
||||
|
||||
return result
|
||||
|
||||
def log_memory_usage(obj_name: str = "Anwendung", obj: Any = None, logger: Optional[logging.Logger] = None):
|
||||
"""
|
||||
Loggt den aktuellen Speicherverbrauch.
|
||||
|
||||
Args:
|
||||
obj_name: Name des Objekts oder der Anwendung
|
||||
obj: Optional ein Objekt, dessen Größe gemessen werden soll
|
||||
logger: Logger-Instanz für die Protokollierung (optional)
|
||||
"""
|
||||
log = logger or debug_logger
|
||||
memory = memory_usage(obj)
|
||||
|
||||
log.info(f"📊 Speicherverbrauch von {obj_name}:")
|
||||
log.info(f" RSS: {memory['rss']:.2f} MB")
|
||||
log.info(f" VMS: {memory['vms']:.2f} MB")
|
||||
log.info(f" Prozent: {memory['percent']:.2f}%")
|
||||
|
||||
if 'object_size' in memory:
|
||||
if isinstance(memory['object_size'], (int, float)):
|
||||
log.info(f" Objektgröße: {memory['object_size']:.2f} KB")
|
||||
else:
|
||||
log.info(f" Objektgröße: {memory['object_size']}")
|
||||
|
||||
def profile_function(func):
|
||||
"""
|
||||
Dekorator, der eine Funktion profiliert und Statistiken ausgibt.
|
||||
|
||||
Args:
|
||||
func: Die zu profilierende Funktion
|
||||
|
||||
Returns:
|
||||
Dekorierte Funktion
|
||||
"""
|
||||
@wraps(func)
|
||||
def wrapper(*args, **kwargs):
|
||||
try:
|
||||
import cProfile
|
||||
import pstats
|
||||
import io
|
||||
|
||||
# Profiler erstellen und Funktion ausführen
|
||||
profiler = cProfile.Profile()
|
||||
profiler.enable()
|
||||
result = func(*args, **kwargs)
|
||||
profiler.disable()
|
||||
|
||||
# Statistiken sammeln
|
||||
s = io.StringIO()
|
||||
ps = pstats.Stats(profiler, stream=s).sort_stats('cumulative')
|
||||
ps.print_stats(20) # Top 20 Zeilen
|
||||
|
||||
# Statistiken ausgeben
|
||||
debug_print(f"📊 Profiling-Ergebnis für {func.__name__}:", DebugLevel.VERBOSE)
|
||||
for line in s.getvalue().split('\n'):
|
||||
if line.strip():
|
||||
debug_print(f" {line}", DebugLevel.VERBOSE)
|
||||
|
||||
return result
|
||||
except ImportError:
|
||||
debug_print(f"⚠️ cProfile nicht verfügbar, Funktion wird ohne Profiling ausgeführt", DebugLevel.NORMAL)
|
||||
return func(*args, **kwargs)
|
||||
|
||||
return wrapper
|
||||
@ -1,405 +0,0 @@
|
||||
#!/usr/bin/env python3.11
|
||||
"""
|
||||
Development Utilities - Konsolidierte Entwicklungs- und Test-Hilfsfunktionen
|
||||
Zusammenfassung von Datenbank-Tests, Session-Fixes und anderen Entwicklungstools
|
||||
"""
|
||||
|
||||
import re
|
||||
import os
|
||||
import sys
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
# Logger initialisieren
|
||||
logger = get_logger("development_utilities")
|
||||
|
||||
# ===== DATENBANK-TESTS =====
|
||||
|
||||
def test_database_connectivity():
|
||||
"""
|
||||
Testet die grundlegende Datenbank-Konnektivität.
|
||||
|
||||
Returns:
|
||||
dict: Test-Ergebnisse
|
||||
"""
|
||||
try:
|
||||
from models import get_cached_session, User, Printer, Job
|
||||
|
||||
logger.info("=== DATENBANK-KONNEKTIVITÄTS-TEST ===")
|
||||
|
||||
results = {
|
||||
'success': True,
|
||||
'tests': {},
|
||||
'errors': []
|
||||
}
|
||||
|
||||
with get_cached_session() as session:
|
||||
# Test User-Query
|
||||
try:
|
||||
users = session.query(User).limit(5).all()
|
||||
results['tests']['users'] = {
|
||||
'success': True,
|
||||
'count': len(users),
|
||||
'sample': users[0].username if users else None
|
||||
}
|
||||
logger.info(f"✓ User-Abfrage erfolgreich - {len(users)} Benutzer gefunden")
|
||||
|
||||
if users:
|
||||
user = users[0]
|
||||
logger.info(f"✓ Test-User: {user.username} ({user.email})")
|
||||
logger.info(f"✓ updated_at-Feld: {user.updated_at}")
|
||||
|
||||
except Exception as e:
|
||||
results['tests']['users'] = {'success': False, 'error': str(e)}
|
||||
results['errors'].append(f"User-Test: {str(e)}")
|
||||
logger.error(f"❌ User-Test fehlgeschlagen: {str(e)}")
|
||||
|
||||
# Test Printer-Query
|
||||
try:
|
||||
printers = session.query(Printer).limit(5).all()
|
||||
results['tests']['printers'] = {
|
||||
'success': True,
|
||||
'count': len(printers),
|
||||
'sample': printers[0].name if printers else None
|
||||
}
|
||||
logger.info(f"✓ Printer-Abfrage erfolgreich - {len(printers)} Drucker gefunden")
|
||||
|
||||
except Exception as e:
|
||||
results['tests']['printers'] = {'success': False, 'error': str(e)}
|
||||
results['errors'].append(f"Printer-Test: {str(e)}")
|
||||
logger.error(f"❌ Printer-Test fehlgeschlagen: {str(e)}")
|
||||
|
||||
# Test Job-Query
|
||||
try:
|
||||
jobs = session.query(Job).limit(5).all()
|
||||
results['tests']['jobs'] = {
|
||||
'success': True,
|
||||
'count': len(jobs),
|
||||
'sample': jobs[0].title if jobs else None
|
||||
}
|
||||
logger.info(f"✓ Job-Abfrage erfolgreich - {len(jobs)} Jobs gefunden")
|
||||
|
||||
except Exception as e:
|
||||
results['tests']['jobs'] = {'success': False, 'error': str(e)}
|
||||
results['errors'].append(f"Job-Test: {str(e)}")
|
||||
logger.error(f"❌ Job-Test fehlgeschlagen: {str(e)}")
|
||||
|
||||
if results['errors']:
|
||||
results['success'] = False
|
||||
logger.error("❌ DATENBANK-TESTS TEILWEISE FEHLGESCHLAGEN")
|
||||
else:
|
||||
logger.info("🎉 ALLE DATENBANK-TESTS ERFOLGREICH!")
|
||||
logger.info("Die Anwendung sollte jetzt ohne Fehler starten.")
|
||||
|
||||
return results
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"❌ KRITISCHER DATENBANK-TEST-FEHLER: {str(e)}")
|
||||
return {
|
||||
'success': False,
|
||||
'tests': {},
|
||||
'errors': [f"Kritischer Fehler: {str(e)}"]
|
||||
}
|
||||
|
||||
def test_database_schema():
|
||||
"""
|
||||
Testet die Datenbank-Schema-Integrität.
|
||||
|
||||
Returns:
|
||||
dict: Schema-Test-Ergebnisse
|
||||
"""
|
||||
try:
|
||||
from models import get_cached_session, User, Printer, Job, GuestRequest
|
||||
from sqlalchemy import inspect
|
||||
|
||||
logger.info("=== DATENBANK-SCHEMA-TEST ===")
|
||||
|
||||
results = {
|
||||
'success': True,
|
||||
'tables': {},
|
||||
'errors': []
|
||||
}
|
||||
|
||||
with get_cached_session() as session:
|
||||
inspector = inspect(session.bind)
|
||||
|
||||
# Erwartete Tabellen
|
||||
expected_tables = ['users', 'printers', 'jobs', 'guest_requests', 'system_logs']
|
||||
|
||||
for table_name in expected_tables:
|
||||
try:
|
||||
if inspector.has_table(table_name):
|
||||
columns = inspector.get_columns(table_name)
|
||||
results['tables'][table_name] = {
|
||||
'exists': True,
|
||||
'columns': len(columns),
|
||||
'column_names': [col['name'] for col in columns]
|
||||
}
|
||||
logger.info(f"✓ Tabelle '{table_name}': {len(columns)} Spalten")
|
||||
else:
|
||||
results['tables'][table_name] = {'exists': False}
|
||||
results['errors'].append(f"Tabelle '{table_name}' nicht gefunden")
|
||||
logger.error(f"❌ Tabelle '{table_name}' nicht gefunden")
|
||||
|
||||
except Exception as e:
|
||||
results['tables'][table_name] = {'exists': False, 'error': str(e)}
|
||||
results['errors'].append(f"Tabelle '{table_name}': {str(e)}")
|
||||
logger.error(f"❌ Fehler bei Tabelle '{table_name}': {str(e)}")
|
||||
|
||||
if results['errors']:
|
||||
results['success'] = False
|
||||
logger.error("❌ SCHEMA-TESTS TEILWEISE FEHLGESCHLAGEN")
|
||||
else:
|
||||
logger.info("🎉 ALLE SCHEMA-TESTS ERFOLGREICH!")
|
||||
|
||||
return results
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"❌ KRITISCHER SCHEMA-TEST-FEHLER: {str(e)}")
|
||||
return {
|
||||
'success': False,
|
||||
'tables': {},
|
||||
'errors': [f"Kritischer Fehler: {str(e)}"]
|
||||
}
|
||||
|
||||
# ===== SESSION-FIXES =====
|
||||
|
||||
def fix_session_usage_in_file(file_path):
|
||||
"""
|
||||
Behebt Session-Usage in einer Datei durch Konvertierung zu Context Manager Pattern.
|
||||
|
||||
Args:
|
||||
file_path (str): Pfad zur zu reparierenden Datei
|
||||
|
||||
Returns:
|
||||
dict: Reparatur-Ergebnisse
|
||||
"""
|
||||
try:
|
||||
if not os.path.exists(file_path):
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Datei nicht gefunden: {file_path}',
|
||||
'changes_made': False
|
||||
}
|
||||
|
||||
with open(file_path, 'r', encoding='utf-8') as f:
|
||||
content = f.read()
|
||||
|
||||
# Pattern für direkte Session-Aufrufe
|
||||
patterns = [
|
||||
# session = get_cached_session() -> with get_cached_session() as session:
|
||||
(r'(\s+)session = get_cached_session\(\)', r'\1with get_cached_session() as session:'),
|
||||
|
||||
# session.close() entfernen (wird automatisch durch Context Manager gemacht)
|
||||
(r'\s+session\.close\(\)\s*\n', '\n'),
|
||||
]
|
||||
|
||||
original_content = content
|
||||
changes_count = 0
|
||||
|
||||
for pattern, replacement in patterns:
|
||||
new_content = re.sub(pattern, replacement, content, flags=re.MULTILINE)
|
||||
|
||||
if new_content != content:
|
||||
changes_count += 1
|
||||
content = new_content
|
||||
|
||||
# Nur schreiben wenn sich etwas geändert hat
|
||||
if content != original_content:
|
||||
with open(file_path, 'w', encoding='utf-8') as f:
|
||||
f.write(content)
|
||||
|
||||
logger.info(f"✅ {file_path} wurde aktualisiert ({changes_count} Änderungen)")
|
||||
return {
|
||||
'success': True,
|
||||
'message': f'Datei erfolgreich aktualisiert',
|
||||
'changes_made': True,
|
||||
'changes_count': changes_count
|
||||
}
|
||||
else:
|
||||
logger.info(f"ℹ️ {file_path} benötigt keine Änderungen")
|
||||
return {
|
||||
'success': True,
|
||||
'message': 'Keine Änderungen erforderlich',
|
||||
'changes_made': False,
|
||||
'changes_count': 0
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"❌ Fehler beim Reparieren von {file_path}: {str(e)}")
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Fehler: {str(e)}',
|
||||
'changes_made': False
|
||||
}
|
||||
|
||||
def fix_session_usage_bulk(directory_path=None):
|
||||
"""
|
||||
Repariert Session-Usage in mehreren Dateien.
|
||||
|
||||
Args:
|
||||
directory_path (str): Verzeichnis zum Durchsuchen (Standard: blueprints/)
|
||||
|
||||
Returns:
|
||||
dict: Bulk-Reparatur-Ergebnisse
|
||||
"""
|
||||
if directory_path is None:
|
||||
backend_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
directory_path = os.path.join(backend_dir, 'blueprints')
|
||||
|
||||
results = {
|
||||
'success': True,
|
||||
'files_processed': 0,
|
||||
'files_changed': 0,
|
||||
'total_changes': 0,
|
||||
'errors': []
|
||||
}
|
||||
|
||||
try:
|
||||
for root, dirs, files in os.walk(directory_path):
|
||||
for file in files:
|
||||
if file.endswith('.py'):
|
||||
file_path = os.path.join(root, file)
|
||||
result = fix_session_usage_in_file(file_path)
|
||||
|
||||
results['files_processed'] += 1
|
||||
|
||||
if result['success']:
|
||||
if result['changes_made']:
|
||||
results['files_changed'] += 1
|
||||
results['total_changes'] += result.get('changes_count', 0)
|
||||
else:
|
||||
results['errors'].append(f"{file_path}: {result['message']}")
|
||||
results['success'] = False
|
||||
|
||||
logger.info(f"Bulk-Reparatur abgeschlossen: {results['files_processed']} Dateien verarbeitet, {results['files_changed']} geändert")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"❌ Fehler bei Bulk-Reparatur: {str(e)}")
|
||||
results['success'] = False
|
||||
results['errors'].append(f"Bulk-Fehler: {str(e)}")
|
||||
|
||||
return results
|
||||
|
||||
# ===== CODE-QUALITÄT =====
|
||||
|
||||
def analyze_code_quality(file_path):
|
||||
"""
|
||||
Analysiert die Code-Qualität einer Python-Datei.
|
||||
|
||||
Args:
|
||||
file_path (str): Pfad zur zu analysierenden Datei
|
||||
|
||||
Returns:
|
||||
dict: Code-Qualitäts-Analyse
|
||||
"""
|
||||
try:
|
||||
if not os.path.exists(file_path):
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Datei nicht gefunden: {file_path}'
|
||||
}
|
||||
|
||||
with open(file_path, 'r', encoding='utf-8') as f:
|
||||
content = f.read()
|
||||
|
||||
lines = content.split('\n')
|
||||
|
||||
analysis = {
|
||||
'success': True,
|
||||
'file_path': file_path,
|
||||
'metrics': {
|
||||
'total_lines': len(lines),
|
||||
'code_lines': len([line for line in lines if line.strip() and not line.strip().startswith('#')]),
|
||||
'comment_lines': len([line for line in lines if line.strip().startswith('#')]),
|
||||
'empty_lines': len([line for line in lines if not line.strip()]),
|
||||
'functions': len(re.findall(r'^\s*def\s+\w+', content, re.MULTILINE)),
|
||||
'classes': len(re.findall(r'^\s*class\s+\w+', content, re.MULTILINE)),
|
||||
'imports': len(re.findall(r'^\s*(import|from)\s+', content, re.MULTILINE))
|
||||
},
|
||||
'issues': []
|
||||
}
|
||||
|
||||
# Potentielle Probleme identifizieren
|
||||
if analysis['metrics']['total_lines'] > 1000:
|
||||
analysis['issues'].append('Datei sehr groß (>1000 Zeilen) - Aufteilung empfohlen')
|
||||
|
||||
if analysis['metrics']['functions'] > 50:
|
||||
analysis['issues'].append('Viele Funktionen (>50) - Modularisierung empfohlen')
|
||||
|
||||
# TODO-Kommentare finden
|
||||
todos = re.findall(r'#.*TODO.*', content, re.IGNORECASE)
|
||||
if todos:
|
||||
analysis['metrics']['todos'] = len(todos)
|
||||
analysis['issues'].append(f'{len(todos)} TODO-Kommentare gefunden')
|
||||
|
||||
return analysis
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"❌ Fehler bei Code-Qualitäts-Analyse von {file_path}: {str(e)}")
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Fehler: {str(e)}'
|
||||
}
|
||||
|
||||
# ===== CLI INTERFACE =====
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) > 1:
|
||||
command = sys.argv[1]
|
||||
|
||||
if command == "test-db":
|
||||
result = test_database_connectivity()
|
||||
if result['success']:
|
||||
print("🎉 Datenbank-Tests erfolgreich!")
|
||||
else:
|
||||
print("❌ Datenbank-Tests fehlgeschlagen:")
|
||||
for error in result['errors']:
|
||||
print(f" - {error}")
|
||||
|
||||
elif command == "test-schema":
|
||||
result = test_database_schema()
|
||||
if result['success']:
|
||||
print("🎉 Schema-Tests erfolgreich!")
|
||||
else:
|
||||
print("❌ Schema-Tests fehlgeschlagen:")
|
||||
for error in result['errors']:
|
||||
print(f" - {error}")
|
||||
|
||||
elif command == "fix-sessions":
|
||||
if len(sys.argv) > 2:
|
||||
file_path = sys.argv[2]
|
||||
result = fix_session_usage_in_file(file_path)
|
||||
print(f"{'✅' if result['success'] else '❌'} {result['message']}")
|
||||
else:
|
||||
result = fix_session_usage_bulk()
|
||||
print(f"Bulk-Reparatur: {result['files_changed']}/{result['files_processed']} Dateien geändert")
|
||||
|
||||
elif command == "analyze":
|
||||
if len(sys.argv) > 2:
|
||||
file_path = sys.argv[2]
|
||||
result = analyze_code_quality(file_path)
|
||||
if result['success']:
|
||||
metrics = result['metrics']
|
||||
print(f"=== Code-Analyse: {os.path.basename(file_path)} ===")
|
||||
print(f"Zeilen gesamt: {metrics['total_lines']}")
|
||||
print(f"Code-Zeilen: {metrics['code_lines']}")
|
||||
print(f"Funktionen: {metrics['functions']}")
|
||||
print(f"Klassen: {metrics['classes']}")
|
||||
if result['issues']:
|
||||
print("Probleme:")
|
||||
for issue in result['issues']:
|
||||
print(f" ⚠️ {issue}")
|
||||
else:
|
||||
print(f"❌ {result['message']}")
|
||||
else:
|
||||
print("Verwendung: python3.11 development_utilities.py analyze <datei>")
|
||||
|
||||
else:
|
||||
print("Verfügbare Kommandos:")
|
||||
print(" test-db - Testet Datenbank-Konnektivität")
|
||||
print(" test-schema - Testet Datenbank-Schema")
|
||||
print(" fix-sessions [datei] - Repariert Session-Usage")
|
||||
print(" analyze <datei> - Analysiert Code-Qualität")
|
||||
else:
|
||||
print("Verwendung: python3.11 development_utilities.py <command>")
|
||||
print("Verfügbare Kommandos: test-db, test-schema, fix-sessions, analyze")
|
||||
@ -1,663 +0,0 @@
|
||||
"""
|
||||
Erweiterte Formular-Validierung für das MYP-System
|
||||
==================================================
|
||||
|
||||
Dieses Modul stellt umfassende Client- und serverseitige Validierung
|
||||
mit benutzerfreundlichem UI-Feedback bereit.
|
||||
|
||||
Funktionen:
|
||||
- Multi-Level-Validierung (Client/Server)
|
||||
- Echtzeitvalidierung mit JavaScript
|
||||
- Barrierefreie Fehlermeldungen
|
||||
- Custom Validators für spezielle Anforderungen
|
||||
- Automatische Sanitization von Eingaben
|
||||
"""
|
||||
|
||||
import re
|
||||
import html
|
||||
import json
|
||||
import logging
|
||||
from typing import Dict, List, Any, Optional, Callable, Union
|
||||
from datetime import datetime, timedelta
|
||||
from flask import request, jsonify, session
|
||||
from functools import wraps
|
||||
from werkzeug.datastructures import FileStorage
|
||||
|
||||
from utils.logging_config import get_logger
|
||||
from utils.settings import ALLOWED_EXTENSIONS, MAX_FILE_SIZE
|
||||
|
||||
logger = get_logger("validation")
|
||||
|
||||
class ValidationError(Exception):
|
||||
"""Custom Exception für Validierungsfehler"""
|
||||
def __init__(self, message: str, field: str = None, code: str = None):
|
||||
self.message = message
|
||||
self.field = field
|
||||
self.code = code
|
||||
super().__init__(self.message)
|
||||
|
||||
class ValidationResult:
|
||||
"""Ergebnis einer Validierung"""
|
||||
def __init__(self):
|
||||
self.is_valid = True
|
||||
self.errors: Dict[str, List[str]] = {}
|
||||
self.warnings: Dict[str, List[str]] = {}
|
||||
self.cleaned_data: Dict[str, Any] = {}
|
||||
|
||||
def add_error(self, field: str, message: str):
|
||||
"""Fügt einen Validierungsfehler hinzu"""
|
||||
if field not in self.errors:
|
||||
self.errors[field] = []
|
||||
self.errors[field].append(message)
|
||||
self.is_valid = False
|
||||
|
||||
def add_warning(self, field: str, message: str):
|
||||
"""Fügt eine Warnung hinzu"""
|
||||
if field not in self.warnings:
|
||||
self.warnings[field] = []
|
||||
self.warnings[field].append(message)
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
"""Konvertiert das Ergebnis zu einem Dictionary"""
|
||||
return {
|
||||
"is_valid": self.is_valid,
|
||||
"errors": self.errors,
|
||||
"warnings": self.warnings,
|
||||
"cleaned_data": self.cleaned_data
|
||||
}
|
||||
|
||||
class BaseValidator:
|
||||
"""Basis-Klasse für alle Validatoren"""
|
||||
|
||||
def __init__(self, required: bool = False, allow_empty: bool = True):
|
||||
self.required = required
|
||||
self.allow_empty = allow_empty
|
||||
|
||||
def validate(self, value: Any, field_name: str = None) -> ValidationResult:
|
||||
"""Führt die Validierung durch"""
|
||||
result = ValidationResult()
|
||||
|
||||
# Prüfung auf erforderliche Felder
|
||||
if self.required and (value is None or value == ""):
|
||||
result.add_error(field_name or "field", "Dieses Feld ist erforderlich.")
|
||||
return result
|
||||
|
||||
# Wenn Wert leer und erlaubt, keine weitere Validierung
|
||||
if not value and self.allow_empty:
|
||||
result.cleaned_data[field_name or "field"] = value
|
||||
return result
|
||||
|
||||
return self._validate_value(value, field_name, result)
|
||||
|
||||
def _validate_value(self, value: Any, field_name: str, result: ValidationResult) -> ValidationResult:
|
||||
"""Überschreibbar für spezifische Validierungslogik"""
|
||||
result.cleaned_data[field_name or "field"] = value
|
||||
return result
|
||||
|
||||
class StringValidator(BaseValidator):
|
||||
"""Validator für String-Werte"""
|
||||
|
||||
def __init__(self, min_length: int = None, max_length: int = None,
|
||||
pattern: str = None, trim: bool = True, **kwargs):
|
||||
super().__init__(**kwargs)
|
||||
self.min_length = min_length
|
||||
self.max_length = max_length
|
||||
self.pattern = re.compile(pattern) if pattern else None
|
||||
self.trim = trim
|
||||
|
||||
def _validate_value(self, value: Any, field_name: str, result: ValidationResult) -> ValidationResult:
|
||||
# String konvertieren und trimmen
|
||||
str_value = str(value)
|
||||
if self.trim:
|
||||
str_value = str_value.strip()
|
||||
|
||||
# Längenprüfung
|
||||
if self.min_length is not None and len(str_value) < self.min_length:
|
||||
result.add_error(field_name, f"Mindestlänge: {self.min_length} Zeichen")
|
||||
|
||||
if self.max_length is not None and len(str_value) > self.max_length:
|
||||
result.add_error(field_name, f"Maximallänge: {self.max_length} Zeichen")
|
||||
|
||||
# Pattern-Prüfung
|
||||
if self.pattern and not self.pattern.match(str_value):
|
||||
result.add_error(field_name, "Format ist ungültig")
|
||||
|
||||
# HTML-Sanitization
|
||||
cleaned_value = html.escape(str_value)
|
||||
result.cleaned_data[field_name] = cleaned_value
|
||||
|
||||
return result
|
||||
|
||||
class EmailValidator(StringValidator):
|
||||
"""Validator für E-Mail-Adressen"""
|
||||
|
||||
EMAIL_PATTERN = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
|
||||
|
||||
def __init__(self, **kwargs):
|
||||
super().__init__(pattern=self.EMAIL_PATTERN, **kwargs)
|
||||
|
||||
def _validate_value(self, value: Any, field_name: str, result: ValidationResult) -> ValidationResult:
|
||||
result = super()._validate_value(value, field_name, result)
|
||||
|
||||
if result.is_valid:
|
||||
# Normalisierung der E-Mail
|
||||
email = str(value).lower().strip()
|
||||
result.cleaned_data[field_name] = email
|
||||
|
||||
return result
|
||||
|
||||
class IntegerValidator(BaseValidator):
|
||||
"""Validator für Integer-Werte"""
|
||||
|
||||
def __init__(self, min_value: int = None, max_value: int = None, **kwargs):
|
||||
super().__init__(**kwargs)
|
||||
self.min_value = min_value
|
||||
self.max_value = max_value
|
||||
|
||||
def _validate_value(self, value: Any, field_name: str, result: ValidationResult) -> ValidationResult:
|
||||
try:
|
||||
int_value = int(value)
|
||||
except (ValueError, TypeError):
|
||||
result.add_error(field_name, "Muss eine ganze Zahl sein")
|
||||
return result
|
||||
|
||||
if self.min_value is not None and int_value < self.min_value:
|
||||
result.add_error(field_name, f"Mindestwert: {self.min_value}")
|
||||
|
||||
if self.max_value is not None and int_value > self.max_value:
|
||||
result.add_error(field_name, f"Maximalwert: {self.max_value}")
|
||||
|
||||
result.cleaned_data[field_name] = int_value
|
||||
return result
|
||||
|
||||
class FloatValidator(BaseValidator):
|
||||
"""Validator für Float-Werte"""
|
||||
|
||||
def __init__(self, min_value: float = None, max_value: float = None,
|
||||
decimal_places: int = None, **kwargs):
|
||||
super().__init__(**kwargs)
|
||||
self.min_value = min_value
|
||||
self.max_value = max_value
|
||||
self.decimal_places = decimal_places
|
||||
|
||||
def _validate_value(self, value: Any, field_name: str, result: ValidationResult) -> ValidationResult:
|
||||
try:
|
||||
float_value = float(value)
|
||||
except (ValueError, TypeError):
|
||||
result.add_error(field_name, "Muss eine Dezimalzahl sein")
|
||||
return result
|
||||
|
||||
if self.min_value is not None and float_value < self.min_value:
|
||||
result.add_error(field_name, f"Mindestwert: {self.min_value}")
|
||||
|
||||
if self.max_value is not None and float_value > self.max_value:
|
||||
result.add_error(field_name, f"Maximalwert: {self.max_value}")
|
||||
|
||||
# Rundung auf bestimmte Dezimalstellen
|
||||
if self.decimal_places is not None:
|
||||
float_value = round(float_value, self.decimal_places)
|
||||
|
||||
result.cleaned_data[field_name] = float_value
|
||||
return result
|
||||
|
||||
class DateTimeValidator(BaseValidator):
|
||||
"""Validator für DateTime-Werte"""
|
||||
|
||||
def __init__(self, format_string: str = "%Y-%m-%d %H:%M",
|
||||
min_date: datetime = None, max_date: datetime = None, **kwargs):
|
||||
super().__init__(**kwargs)
|
||||
self.format_string = format_string
|
||||
self.min_date = min_date
|
||||
self.max_date = max_date
|
||||
|
||||
def _validate_value(self, value: Any, field_name: str, result: ValidationResult) -> ValidationResult:
|
||||
if isinstance(value, datetime):
|
||||
dt_value = value
|
||||
else:
|
||||
try:
|
||||
dt_value = datetime.strptime(str(value), self.format_string)
|
||||
except ValueError:
|
||||
result.add_error(field_name, f"Ungültiges Datumsformat. Erwartet: {self.format_string}")
|
||||
return result
|
||||
|
||||
if self.min_date and dt_value < self.min_date:
|
||||
result.add_error(field_name, f"Datum muss nach {self.min_date.strftime('%d.%m.%Y')} liegen")
|
||||
|
||||
if self.max_date and dt_value > self.max_date:
|
||||
result.add_error(field_name, f"Datum muss vor {self.max_date.strftime('%d.%m.%Y')} liegen")
|
||||
|
||||
result.cleaned_data[field_name] = dt_value
|
||||
return result
|
||||
|
||||
class FileValidator(BaseValidator):
|
||||
"""Validator für Datei-Uploads"""
|
||||
|
||||
def __init__(self, allowed_extensions: List[str] = None,
|
||||
max_size_mb: int = None, min_size_kb: int = None, **kwargs):
|
||||
super().__init__(**kwargs)
|
||||
self.allowed_extensions = allowed_extensions or ALLOWED_EXTENSIONS
|
||||
self.max_size_mb = max_size_mb or (MAX_FILE_SIZE / (1024 * 1024))
|
||||
self.min_size_kb = min_size_kb
|
||||
|
||||
def _validate_value(self, value: Any, field_name: str, result: ValidationResult) -> ValidationResult:
|
||||
if not isinstance(value, FileStorage):
|
||||
result.add_error(field_name, "Muss eine gültige Datei sein")
|
||||
return result
|
||||
|
||||
# Dateiname prüfen
|
||||
if not value.filename:
|
||||
result.add_error(field_name, "Dateiname ist erforderlich")
|
||||
return result
|
||||
|
||||
# Dateierweiterung prüfen
|
||||
extension = value.filename.rsplit('.', 1)[-1].lower() if '.' in value.filename else ''
|
||||
if extension not in self.allowed_extensions:
|
||||
result.add_error(field_name,
|
||||
f"Nur folgende Dateiformate sind erlaubt: {', '.join(self.allowed_extensions)}")
|
||||
|
||||
# Dateigröße prüfen
|
||||
value.seek(0, 2) # Zum Ende der Datei
|
||||
file_size = value.tell()
|
||||
value.seek(0) # Zurück zum Anfang
|
||||
|
||||
if self.max_size_mb and file_size > (self.max_size_mb * 1024 * 1024):
|
||||
result.add_error(field_name, f"Datei zu groß. Maximum: {self.max_size_mb} MB")
|
||||
|
||||
if self.min_size_kb and file_size < (self.min_size_kb * 1024):
|
||||
result.add_error(field_name, f"Datei zu klein. Minimum: {self.min_size_kb} KB")
|
||||
|
||||
result.cleaned_data[field_name] = value
|
||||
return result
|
||||
|
||||
class FormValidator:
|
||||
"""Haupt-Formular-Validator"""
|
||||
|
||||
def __init__(self):
|
||||
self.fields: Dict[str, BaseValidator] = {}
|
||||
self.custom_validators: List[Callable] = []
|
||||
self.rate_limit_key = None
|
||||
self.csrf_check = True
|
||||
|
||||
def add_field(self, name: str, validator: BaseValidator):
|
||||
"""Fügt ein Feld mit Validator hinzu"""
|
||||
self.fields[name] = validator
|
||||
return self
|
||||
|
||||
def add_custom_validator(self, validator_func: Callable):
|
||||
"""Fügt einen benutzerdefinierten Validator hinzu"""
|
||||
self.custom_validators.append(validator_func)
|
||||
return self
|
||||
|
||||
def set_rate_limit(self, key: str):
|
||||
"""Setzt einen Rate-Limiting-Schlüssel"""
|
||||
self.rate_limit_key = key
|
||||
return self
|
||||
|
||||
def disable_csrf(self):
|
||||
"""Deaktiviert CSRF-Prüfung für dieses Formular"""
|
||||
self.csrf_check = False
|
||||
return self
|
||||
|
||||
def validate(self, data: Dict[str, Any]) -> ValidationResult:
|
||||
"""Validiert die gesamten Formulardaten"""
|
||||
result = ValidationResult()
|
||||
|
||||
# Einzelfeldvalidierung
|
||||
for field_name, validator in self.fields.items():
|
||||
field_value = data.get(field_name)
|
||||
field_result = validator.validate(field_value, field_name)
|
||||
|
||||
if not field_result.is_valid:
|
||||
result.errors.update(field_result.errors)
|
||||
result.is_valid = False
|
||||
|
||||
result.warnings.update(field_result.warnings)
|
||||
result.cleaned_data.update(field_result.cleaned_data)
|
||||
|
||||
# Benutzerdefinierte Validierung
|
||||
if result.is_valid:
|
||||
for custom_validator in self.custom_validators:
|
||||
try:
|
||||
custom_result = custom_validator(result.cleaned_data)
|
||||
if isinstance(custom_result, ValidationResult):
|
||||
if not custom_result.is_valid:
|
||||
result.errors.update(custom_result.errors)
|
||||
result.is_valid = False
|
||||
result.warnings.update(custom_result.warnings)
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei benutzerdefinierter Validierung: {str(e)}")
|
||||
result.add_error("form", "Unerwarteter Validierungsfehler")
|
||||
|
||||
return result
|
||||
|
||||
# Vordefinierte Formular-Validatoren
|
||||
def get_user_registration_validator() -> FormValidator:
|
||||
"""Validator für Benutzerregistrierung"""
|
||||
return FormValidator() \
|
||||
.add_field("username", StringValidator(min_length=3, max_length=50, required=True)) \
|
||||
.add_field("email", EmailValidator(required=True)) \
|
||||
.add_field("password", StringValidator(min_length=8, required=True)) \
|
||||
.add_field("password_confirm", StringValidator(min_length=8, required=True)) \
|
||||
.add_field("name", StringValidator(min_length=2, max_length=100, required=True)) \
|
||||
.add_custom_validator(lambda data: _validate_password_match(data))
|
||||
|
||||
def get_job_creation_validator() -> FormValidator:
|
||||
"""Validator für Job-Erstellung"""
|
||||
return FormValidator() \
|
||||
.add_field("name", StringValidator(min_length=1, max_length=200, required=True)) \
|
||||
.add_field("description", StringValidator(max_length=500)) \
|
||||
.add_field("printer_id", IntegerValidator(min_value=1, required=True)) \
|
||||
.add_field("duration_minutes", IntegerValidator(min_value=1, max_value=1440, required=True)) \
|
||||
.add_field("start_at", DateTimeValidator(min_date=datetime.now())) \
|
||||
.add_field("file", FileValidator(required=True))
|
||||
|
||||
def get_printer_creation_validator() -> FormValidator:
|
||||
"""Validator für Drucker-Erstellung"""
|
||||
return FormValidator() \
|
||||
.add_field("name", StringValidator(min_length=1, max_length=100, required=True)) \
|
||||
.add_field("model", StringValidator(max_length=100)) \
|
||||
.add_field("location", StringValidator(max_length=100)) \
|
||||
.add_field("ip_address", StringValidator(pattern=r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$')) \
|
||||
.add_field("mac_address", StringValidator(pattern=r'^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$', required=True)) \
|
||||
.add_field("plug_ip", StringValidator(pattern=r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$', required=True)) \
|
||||
.add_field("plug_username", StringValidator(min_length=1, required=True)) \
|
||||
.add_field("plug_password", StringValidator(min_length=1, required=True))
|
||||
|
||||
def get_guest_request_validator() -> FormValidator:
|
||||
"""Validator für Gastanfragen"""
|
||||
return FormValidator() \
|
||||
.add_field("name", StringValidator(min_length=2, max_length=100, required=True)) \
|
||||
.add_field("email", EmailValidator()) \
|
||||
.add_field("reason", StringValidator(min_length=10, max_length=500, required=True)) \
|
||||
.add_field("duration_minutes", IntegerValidator(min_value=5, max_value=480, required=True)) \
|
||||
.add_field("copies", IntegerValidator(min_value=1, max_value=10)) \
|
||||
.add_field("file", FileValidator(required=True)) \
|
||||
.set_rate_limit("guest_request")
|
||||
|
||||
def _validate_password_match(data: Dict[str, Any]) -> ValidationResult:
|
||||
"""Validiert, ob Passwörter übereinstimmen"""
|
||||
result = ValidationResult()
|
||||
|
||||
password = data.get("password")
|
||||
password_confirm = data.get("password_confirm")
|
||||
|
||||
if password != password_confirm:
|
||||
result.add_error("password_confirm", "Passwörter stimmen nicht überein")
|
||||
|
||||
return result
|
||||
|
||||
# Decorator für automatische Formularvalidierung
|
||||
def validate_form(validator_func: Callable[[], FormValidator]):
|
||||
"""Decorator für automatische Formularvalidierung"""
|
||||
def decorator(f):
|
||||
@wraps(f)
|
||||
def decorated_function(*args, **kwargs):
|
||||
try:
|
||||
# Validator erstellen
|
||||
validator = validator_func()
|
||||
|
||||
# Daten aus Request extrahieren
|
||||
if request.is_json:
|
||||
data = request.get_json() or {}
|
||||
else:
|
||||
data = dict(request.form)
|
||||
# Dateien hinzufügen
|
||||
for key, file in request.files.items():
|
||||
data[key] = file
|
||||
|
||||
# Validierung durchführen
|
||||
validation_result = validator.validate(data)
|
||||
|
||||
# Bei Fehlern JSON-Response zurückgeben
|
||||
if not validation_result.is_valid:
|
||||
logger.warning(f"Validierungsfehler für {request.endpoint}: {validation_result.errors}")
|
||||
return jsonify({
|
||||
"success": False,
|
||||
"errors": validation_result.errors,
|
||||
"warnings": validation_result.warnings
|
||||
}), 400
|
||||
|
||||
# Gereinigte Daten an die Request anhängen
|
||||
request.validated_data = validation_result.cleaned_data
|
||||
request.validation_warnings = validation_result.warnings
|
||||
|
||||
return f(*args, **kwargs)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Formularvalidierung: {str(e)}")
|
||||
return jsonify({
|
||||
"success": False,
|
||||
"errors": {"form": ["Unerwarteter Validierungsfehler"]}
|
||||
}), 500
|
||||
|
||||
return decorated_function
|
||||
return decorator
|
||||
|
||||
# JavaScript für Client-seitige Validierung
|
||||
def get_client_validation_js() -> str:
|
||||
"""Generiert JavaScript für Client-seitige Validierung"""
|
||||
return """
|
||||
class FormValidator {
|
||||
constructor(formId, validationRules = {}) {
|
||||
this.form = document.getElementById(formId);
|
||||
this.rules = validationRules;
|
||||
this.errors = {};
|
||||
this.setupEventListeners();
|
||||
}
|
||||
|
||||
setupEventListeners() {
|
||||
if (!this.form) return;
|
||||
|
||||
// Echtzeit-Validierung bei Eingabe
|
||||
this.form.addEventListener('input', (e) => {
|
||||
this.validateField(e.target);
|
||||
});
|
||||
|
||||
// Formular-Submission
|
||||
this.form.addEventListener('submit', (e) => {
|
||||
if (!this.validateForm()) {
|
||||
e.preventDefault();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
validateField(field) {
|
||||
const fieldName = field.name;
|
||||
const value = field.value;
|
||||
const rule = this.rules[fieldName];
|
||||
|
||||
if (!rule) return true;
|
||||
|
||||
this.clearFieldError(field);
|
||||
|
||||
// Required-Prüfung
|
||||
if (rule.required && (!value || value.trim() === '')) {
|
||||
this.addFieldError(field, 'Dieses Feld ist erforderlich.');
|
||||
return false;
|
||||
}
|
||||
|
||||
// Längenprüfung
|
||||
if (rule.minLength && value.length < rule.minLength) {
|
||||
this.addFieldError(field, `Mindestlänge: ${rule.minLength} Zeichen`);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (rule.maxLength && value.length > rule.maxLength) {
|
||||
this.addFieldError(field, `Maximallänge: ${rule.maxLength} Zeichen`);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Pattern-Prüfung
|
||||
if (rule.pattern && !new RegExp(rule.pattern).test(value)) {
|
||||
this.addFieldError(field, rule.patternMessage || 'Format ist ungültig');
|
||||
return false;
|
||||
}
|
||||
|
||||
// Email-Prüfung
|
||||
if (rule.type === 'email' && value) {
|
||||
const emailPattern = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
|
||||
if (!emailPattern.test(value)) {
|
||||
this.addFieldError(field, 'Bitte geben Sie eine gültige E-Mail-Adresse ein');
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Custom Validierung
|
||||
if (rule.customValidator) {
|
||||
const customResult = rule.customValidator(value, field);
|
||||
if (customResult !== true) {
|
||||
this.addFieldError(field, customResult);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
validateForm() {
|
||||
let isValid = true;
|
||||
this.errors = {};
|
||||
|
||||
// Alle Felder validieren
|
||||
const fields = this.form.querySelectorAll('input, textarea, select');
|
||||
fields.forEach(field => {
|
||||
if (!this.validateField(field)) {
|
||||
isValid = false;
|
||||
}
|
||||
});
|
||||
|
||||
// Custom Form-Validierung
|
||||
if (this.rules._formValidator) {
|
||||
const formData = new FormData(this.form);
|
||||
const customResult = this.rules._formValidator(formData, this.form);
|
||||
if (customResult !== true) {
|
||||
this.addFormError(customResult);
|
||||
isValid = false;
|
||||
}
|
||||
}
|
||||
|
||||
return isValid;
|
||||
}
|
||||
|
||||
addFieldError(field, message) {
|
||||
const fieldName = field.name;
|
||||
|
||||
// Error-Container finden oder erstellen
|
||||
let errorContainer = field.parentNode.querySelector('.field-error');
|
||||
if (!errorContainer) {
|
||||
errorContainer = document.createElement('div');
|
||||
errorContainer.className = 'field-error text-red-600 text-sm mt-1';
|
||||
errorContainer.setAttribute('role', 'alert');
|
||||
errorContainer.setAttribute('aria-live', 'polite');
|
||||
field.parentNode.appendChild(errorContainer);
|
||||
}
|
||||
|
||||
errorContainer.textContent = message;
|
||||
field.classList.add('border-red-500');
|
||||
field.setAttribute('aria-invalid', 'true');
|
||||
|
||||
// Für Screen Reader
|
||||
if (!field.getAttribute('aria-describedby')) {
|
||||
const errorId = `error-${fieldName}-${Date.now()}`;
|
||||
errorContainer.id = errorId;
|
||||
field.setAttribute('aria-describedby', errorId);
|
||||
}
|
||||
|
||||
this.errors[fieldName] = message;
|
||||
}
|
||||
|
||||
clearFieldError(field) {
|
||||
const errorContainer = field.parentNode.querySelector('.field-error');
|
||||
if (errorContainer) {
|
||||
errorContainer.remove();
|
||||
}
|
||||
|
||||
field.classList.remove('border-red-500');
|
||||
field.removeAttribute('aria-invalid');
|
||||
field.removeAttribute('aria-describedby');
|
||||
|
||||
delete this.errors[field.name];
|
||||
}
|
||||
|
||||
addFormError(message) {
|
||||
let formErrorContainer = this.form.querySelector('.form-error');
|
||||
if (!formErrorContainer) {
|
||||
formErrorContainer = document.createElement('div');
|
||||
formErrorContainer.className = 'form-error bg-red-100 border border-red-400 text-red-700 px-4 py-3 rounded mb-4';
|
||||
formErrorContainer.setAttribute('role', 'alert');
|
||||
this.form.insertBefore(formErrorContainer, this.form.firstChild);
|
||||
}
|
||||
|
||||
formErrorContainer.textContent = message;
|
||||
}
|
||||
|
||||
clearFormErrors() {
|
||||
const formErrorContainer = this.form.querySelector('.form-error');
|
||||
if (formErrorContainer) {
|
||||
formErrorContainer.remove();
|
||||
}
|
||||
}
|
||||
|
||||
showServerErrors(errors) {
|
||||
// Server-Fehler anzeigen
|
||||
for (const [fieldName, messages] of Object.entries(errors)) {
|
||||
const field = this.form.querySelector(`[name="${fieldName}"]`);
|
||||
if (field && messages.length > 0) {
|
||||
this.addFieldError(field, messages[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Utility-Funktionen
|
||||
window.FormValidationUtils = {
|
||||
// Passwort-Stärke prüfen
|
||||
validatePasswordStrength: (password) => {
|
||||
if (password.length < 8) return 'Passwort muss mindestens 8 Zeichen lang sein';
|
||||
if (!/[A-Z]/.test(password)) return 'Passwort muss mindestens einen Großbuchstaben enthalten';
|
||||
if (!/[a-z]/.test(password)) return 'Passwort muss mindestens einen Kleinbuchstaben enthalten';
|
||||
if (!/[0-9]/.test(password)) return 'Passwort muss mindestens eine Zahl enthalten';
|
||||
return true;
|
||||
},
|
||||
|
||||
// Passwort-Bestätigung prüfen
|
||||
validatePasswordConfirm: (password, confirm) => {
|
||||
return password === confirm ? true : 'Passwörter stimmen nicht überein';
|
||||
},
|
||||
|
||||
// Datei-Validierung
|
||||
validateFile: (file, allowedTypes = [], maxSizeMB = 10) => {
|
||||
if (!file) return 'Bitte wählen Sie eine Datei aus';
|
||||
|
||||
const fileType = file.name.split('.').pop().toLowerCase();
|
||||
if (allowedTypes.length > 0 && !allowedTypes.includes(fileType)) {
|
||||
return `Nur folgende Dateiformate sind erlaubt: ${allowedTypes.join(', ')}`;
|
||||
}
|
||||
|
||||
if (file.size > maxSizeMB * 1024 * 1024) {
|
||||
return `Datei ist zu groß. Maximum: ${maxSizeMB} MB`;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
};
|
||||
"""
|
||||
|
||||
def render_validation_errors(errors: Dict[str, List[str]]) -> str:
|
||||
"""Rendert Validierungsfehler als HTML"""
|
||||
if not errors:
|
||||
return ""
|
||||
|
||||
html_parts = ['<div class="validation-errors">']
|
||||
|
||||
for field, messages in errors.items():
|
||||
for message in messages:
|
||||
html_parts.append(
|
||||
f'<div class="error-message bg-red-100 border border-red-400 text-red-700 px-4 py-3 rounded mb-2" role="alert">'
|
||||
f'<strong>{field}:</strong> {html.escape(message)}'
|
||||
f'</div>'
|
||||
)
|
||||
|
||||
html_parts.append('</div>')
|
||||
|
||||
return '\n'.join(html_parts)
|
||||
@ -1,197 +0,0 @@
|
||||
"""
|
||||
Performance Tracker Utility
|
||||
Messung der Ausführungszeit von Funktionen für Performance-Monitoring
|
||||
"""
|
||||
|
||||
import time
|
||||
import functools
|
||||
from typing import Callable, Any, Optional
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
# Standard-Logger für Performance-Tracking
|
||||
performance_logger = get_logger("performance")
|
||||
|
||||
def measure_execution_time(logger: Optional[Any] = None, task_name: str = "Task",
|
||||
log_level: str = "INFO", threshold_ms: float = 100.0) -> Callable:
|
||||
"""
|
||||
Decorator zur Messung der Ausführungszeit von Funktionen
|
||||
|
||||
Args:
|
||||
logger: Logger-Instanz (optional, verwendet performance_logger als Standard)
|
||||
task_name: Name der Aufgabe für das Logging
|
||||
log_level: Log-Level (DEBUG, INFO, WARNING, ERROR)
|
||||
threshold_ms: Schwellenwert in Millisekunden ab dem geloggt wird
|
||||
|
||||
Returns:
|
||||
Decorator-Funktion
|
||||
"""
|
||||
def decorator(func: Callable) -> Callable:
|
||||
@functools.wraps(func)
|
||||
def wrapper(*args, **kwargs) -> Any:
|
||||
# Logger bestimmen
|
||||
log = logger if logger else performance_logger
|
||||
|
||||
# Startzeit messen
|
||||
start_time = time.perf_counter()
|
||||
|
||||
try:
|
||||
# Funktion ausführen
|
||||
result = func(*args, **kwargs)
|
||||
|
||||
# Endzeit messen
|
||||
end_time = time.perf_counter()
|
||||
execution_time_ms = (end_time - start_time) * 1000
|
||||
|
||||
# Nur loggen wenn über Schwellenwert
|
||||
if execution_time_ms >= threshold_ms:
|
||||
log_message = f"⏱️ {task_name} - Ausführungszeit: {execution_time_ms:.2f}ms"
|
||||
|
||||
if log_level.upper() == "DEBUG":
|
||||
log.debug(log_message)
|
||||
elif log_level.upper() == "INFO":
|
||||
log.info(log_message)
|
||||
elif log_level.upper() == "WARNING":
|
||||
log.warning(log_message)
|
||||
elif log_level.upper() == "ERROR":
|
||||
log.error(log_message)
|
||||
else:
|
||||
log.info(log_message)
|
||||
|
||||
return result
|
||||
|
||||
except Exception as e:
|
||||
# Auch bei Fehlern die Zeit messen
|
||||
end_time = time.perf_counter()
|
||||
execution_time_ms = (end_time - start_time) * 1000
|
||||
|
||||
error_message = f"❌ {task_name} - Fehler nach {execution_time_ms:.2f}ms: {str(e)}"
|
||||
log.error(error_message)
|
||||
|
||||
# Exception weiterwerfen
|
||||
raise
|
||||
|
||||
return wrapper
|
||||
return decorator
|
||||
|
||||
def measure_time_sync(func: Callable, task_name: str = "Function",
|
||||
logger: Optional[Any] = None) -> tuple[Any, float]:
|
||||
"""
|
||||
Synchrone Zeitmessung für einzelne Funktionsaufrufe
|
||||
|
||||
Args:
|
||||
func: Auszuführende Funktion
|
||||
task_name: Name für das Logging
|
||||
logger: Logger-Instanz (optional)
|
||||
|
||||
Returns:
|
||||
Tuple aus (Ergebnis, Ausführungszeit_in_ms)
|
||||
"""
|
||||
log = logger if logger else performance_logger
|
||||
|
||||
start_time = time.perf_counter()
|
||||
|
||||
try:
|
||||
result = func()
|
||||
end_time = time.perf_counter()
|
||||
execution_time_ms = (end_time - start_time) * 1000
|
||||
|
||||
log.info(f"⏱️ {task_name} - Ausführungszeit: {execution_time_ms:.2f}ms")
|
||||
|
||||
return result, execution_time_ms
|
||||
|
||||
except Exception as e:
|
||||
end_time = time.perf_counter()
|
||||
execution_time_ms = (end_time - start_time) * 1000
|
||||
|
||||
log.error(f"❌ {task_name} - Fehler nach {execution_time_ms:.2f}ms: {str(e)}")
|
||||
raise
|
||||
|
||||
class PerformanceTracker:
|
||||
"""
|
||||
Klasse für erweiterte Performance-Verfolgung
|
||||
"""
|
||||
|
||||
def __init__(self, name: str, logger: Optional[Any] = None):
|
||||
self.name = name
|
||||
self.logger = logger if logger else performance_logger
|
||||
self.start_time = None
|
||||
self.end_time = None
|
||||
self.checkpoints = []
|
||||
|
||||
def start(self):
|
||||
"""Startet die Zeitmessung"""
|
||||
self.start_time = time.perf_counter()
|
||||
self.checkpoints = []
|
||||
self.logger.debug(f"📊 Performance-Tracking gestartet für: {self.name}")
|
||||
|
||||
def checkpoint(self, name: str):
|
||||
"""Fügt einen Checkpoint hinzu"""
|
||||
if self.start_time is None:
|
||||
self.logger.warning(f"⚠️ Checkpoint '{name}' ohne gestartete Messung")
|
||||
return
|
||||
|
||||
current_time = time.perf_counter()
|
||||
elapsed_ms = (current_time - self.start_time) * 1000
|
||||
|
||||
self.checkpoints.append({
|
||||
'name': name,
|
||||
'time': current_time,
|
||||
'elapsed_ms': elapsed_ms
|
||||
})
|
||||
|
||||
self.logger.debug(f"📍 Checkpoint '{name}': {elapsed_ms:.2f}ms")
|
||||
|
||||
def stop(self) -> float:
|
||||
"""Stoppt die Zeitmessung und gibt die Gesamtzeit zurück"""
|
||||
if self.start_time is None:
|
||||
self.logger.warning(f"⚠️ Performance-Tracking wurde nicht gestartet für: {self.name}")
|
||||
return 0.0
|
||||
|
||||
self.end_time = time.perf_counter()
|
||||
total_time_ms = (self.end_time - self.start_time) * 1000
|
||||
|
||||
# Zusammenfassung loggen
|
||||
summary = f"🏁 {self.name} - Gesamtzeit: {total_time_ms:.2f}ms"
|
||||
if self.checkpoints:
|
||||
summary += f" ({len(self.checkpoints)} Checkpoints)"
|
||||
|
||||
self.logger.info(summary)
|
||||
|
||||
# Detaillierte Checkpoint-Info bei DEBUG-Level
|
||||
if self.checkpoints and self.logger.isEnabledFor(10): # DEBUG = 10
|
||||
for i, checkpoint in enumerate(self.checkpoints):
|
||||
if i == 0:
|
||||
duration = checkpoint['elapsed_ms']
|
||||
else:
|
||||
duration = checkpoint['elapsed_ms'] - self.checkpoints[i-1]['elapsed_ms']
|
||||
self.logger.debug(f" 📍 {checkpoint['name']}: +{duration:.2f}ms (total: {checkpoint['elapsed_ms']:.2f}ms)")
|
||||
|
||||
return total_time_ms
|
||||
|
||||
def __enter__(self):
|
||||
"""Context Manager - Start"""
|
||||
self.start()
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc_val, exc_tb):
|
||||
"""Context Manager - Stop"""
|
||||
self.stop()
|
||||
|
||||
# Beispiel-Verwendung:
|
||||
if __name__ == "__main__":
|
||||
# Decorator-Verwendung
|
||||
@measure_execution_time(task_name="Test-Funktion", threshold_ms=0.1)
|
||||
def test_function():
|
||||
time.sleep(0.1)
|
||||
return "Fertig"
|
||||
|
||||
# Context Manager-Verwendung
|
||||
with PerformanceTracker("Test-Performance") as tracker:
|
||||
time.sleep(0.05)
|
||||
tracker.checkpoint("Mitte")
|
||||
time.sleep(0.05)
|
||||
tracker.checkpoint("Ende")
|
||||
|
||||
# Synchrone Messung
|
||||
result, exec_time = measure_time_sync(test_function, "Direkte Messung")
|
||||
print(f"Ergebnis: {result}, Zeit: {exec_time:.2f}ms")
|
||||
@ -1,360 +0,0 @@
|
||||
#!/usr/bin/env python3.11
|
||||
"""
|
||||
Printer Utilities - Konsolidierte Drucker-Management-Hilfsfunktionen
|
||||
Zusammenfassung von Drucker-Aktivierung und Standort-Updates
|
||||
"""
|
||||
|
||||
from models import get_db_session, Printer
|
||||
from utils.logging_config import get_logger
|
||||
from datetime import datetime
|
||||
|
||||
# Logger initialisieren
|
||||
logger = get_logger("printer_utilities")
|
||||
|
||||
# ===== DRUCKER AKTIVIERUNG =====
|
||||
|
||||
def aktiviere_alle_drucker():
|
||||
"""
|
||||
Aktiviert alle Drucker in der Datenbank.
|
||||
|
||||
Returns:
|
||||
dict: Ergebnis der Aktivierung mit Statistiken
|
||||
"""
|
||||
try:
|
||||
session = get_db_session()
|
||||
drucker = session.query(Printer).all()
|
||||
|
||||
if not drucker:
|
||||
logger.warning("Keine Drucker in der Datenbank gefunden.")
|
||||
session.close()
|
||||
return {
|
||||
'success': False,
|
||||
'message': 'Keine Drucker gefunden',
|
||||
'activated_count': 0
|
||||
}
|
||||
|
||||
logger.info(f"Anzahl Drucker: {len(drucker)}")
|
||||
logger.info("Aktiviere alle Drucker...")
|
||||
|
||||
activated_count = 0
|
||||
for d in drucker:
|
||||
if not d.active:
|
||||
d.active = True
|
||||
activated_count += 1
|
||||
logger.info(f"Drucker {d.id}: {d.name} - IP: {d.plug_ip} - Aktiviert")
|
||||
else:
|
||||
logger.debug(f"Drucker {d.id}: {d.name} - Bereits aktiv")
|
||||
|
||||
session.commit()
|
||||
session.close()
|
||||
|
||||
logger.info(f"✅ {activated_count} Drucker wurden erfolgreich aktiviert!")
|
||||
|
||||
return {
|
||||
'success': True,
|
||||
'message': f'{activated_count} Drucker aktiviert',
|
||||
'activated_count': activated_count,
|
||||
'total_count': len(drucker)
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Drucker-Aktivierung: {str(e)}")
|
||||
try:
|
||||
session.rollback()
|
||||
session.close()
|
||||
except:
|
||||
pass
|
||||
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Fehler: {str(e)}',
|
||||
'activated_count': 0
|
||||
}
|
||||
|
||||
def deaktiviere_alle_drucker():
|
||||
"""
|
||||
Deaktiviert alle Drucker in der Datenbank.
|
||||
|
||||
Returns:
|
||||
dict: Ergebnis der Deaktivierung mit Statistiken
|
||||
"""
|
||||
try:
|
||||
session = get_db_session()
|
||||
drucker = session.query(Printer).all()
|
||||
|
||||
if not drucker:
|
||||
logger.warning("Keine Drucker in der Datenbank gefunden.")
|
||||
session.close()
|
||||
return {
|
||||
'success': False,
|
||||
'message': 'Keine Drucker gefunden',
|
||||
'deactivated_count': 0
|
||||
}
|
||||
|
||||
logger.info(f"Anzahl Drucker: {len(drucker)}")
|
||||
logger.info("Deaktiviere alle Drucker...")
|
||||
|
||||
deactivated_count = 0
|
||||
for d in drucker:
|
||||
if d.active:
|
||||
d.active = False
|
||||
deactivated_count += 1
|
||||
logger.info(f"Drucker {d.id}: {d.name} - IP: {d.plug_ip} - Deaktiviert")
|
||||
else:
|
||||
logger.debug(f"Drucker {d.id}: {d.name} - Bereits inaktiv")
|
||||
|
||||
session.commit()
|
||||
session.close()
|
||||
|
||||
logger.info(f"✅ {deactivated_count} Drucker wurden erfolgreich deaktiviert!")
|
||||
|
||||
return {
|
||||
'success': True,
|
||||
'message': f'{deactivated_count} Drucker deaktiviert',
|
||||
'deactivated_count': deactivated_count,
|
||||
'total_count': len(drucker)
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Drucker-Deaktivierung: {str(e)}")
|
||||
try:
|
||||
session.rollback()
|
||||
session.close()
|
||||
except:
|
||||
pass
|
||||
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Fehler: {str(e)}',
|
||||
'deactivated_count': 0
|
||||
}
|
||||
|
||||
# ===== STANDORT-MANAGEMENT =====
|
||||
|
||||
def update_printer_locations(new_location="Werk 040 - Berlin - TBA"):
|
||||
"""
|
||||
Aktualisiert alle Drucker-Standorte zu einem neuen Standort.
|
||||
|
||||
Args:
|
||||
new_location (str): Neuer Standort für alle Drucker
|
||||
|
||||
Returns:
|
||||
dict: Ergebnis der Standort-Aktualisierung mit Statistiken
|
||||
"""
|
||||
try:
|
||||
session = get_db_session()
|
||||
|
||||
# Alle Drucker abrufen
|
||||
all_printers = session.query(Printer).all()
|
||||
logger.info(f"Gefundene Drucker: {len(all_printers)}")
|
||||
|
||||
if not all_printers:
|
||||
logger.warning("Keine Drucker in der Datenbank gefunden.")
|
||||
session.close()
|
||||
return {
|
||||
'success': False,
|
||||
'message': 'Keine Drucker gefunden',
|
||||
'updated_count': 0
|
||||
}
|
||||
|
||||
updated_count = 0
|
||||
location_changes = []
|
||||
|
||||
# Alle Drucker durchgehen und Standort aktualisieren
|
||||
for printer in all_printers:
|
||||
old_location = printer.location
|
||||
if old_location != new_location:
|
||||
printer.location = new_location
|
||||
location_changes.append({
|
||||
'printer_id': printer.id,
|
||||
'printer_name': printer.name,
|
||||
'old_location': old_location,
|
||||
'new_location': new_location
|
||||
})
|
||||
logger.info(f"✅ {printer.name}: '{old_location}' → '{new_location}'")
|
||||
updated_count += 1
|
||||
else:
|
||||
logger.debug(f"Drucker {printer.name}: Standort bereits korrekt")
|
||||
|
||||
# Änderungen speichern
|
||||
session.commit()
|
||||
session.close()
|
||||
|
||||
logger.info(f"✅ {updated_count} Drucker-Standorte erfolgreich aktualisiert")
|
||||
logger.info(f"Neuer Standort: {new_location}")
|
||||
|
||||
return {
|
||||
'success': True,
|
||||
'message': f'{updated_count} Standorte aktualisiert',
|
||||
'updated_count': updated_count,
|
||||
'total_count': len(all_printers),
|
||||
'new_location': new_location,
|
||||
'changes': location_changes
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"❌ Fehler bei der Standort-Aktualisierung: {e}")
|
||||
try:
|
||||
session.rollback()
|
||||
session.close()
|
||||
except:
|
||||
pass
|
||||
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Fehler: {str(e)}',
|
||||
'updated_count': 0
|
||||
}
|
||||
|
||||
def get_printer_locations():
|
||||
"""
|
||||
Gibt eine Übersicht aller Drucker-Standorte zurück.
|
||||
|
||||
Returns:
|
||||
dict: Standort-Statistiken
|
||||
"""
|
||||
try:
|
||||
session = get_db_session()
|
||||
all_printers = session.query(Printer).all()
|
||||
session.close()
|
||||
|
||||
if not all_printers:
|
||||
return {
|
||||
'success': False,
|
||||
'message': 'Keine Drucker gefunden',
|
||||
'locations': {}
|
||||
}
|
||||
|
||||
# Standorte gruppieren
|
||||
locations = {}
|
||||
for printer in all_printers:
|
||||
location = printer.location or 'Unbekannt'
|
||||
if location not in locations:
|
||||
locations[location] = []
|
||||
locations[location].append({
|
||||
'id': printer.id,
|
||||
'name': printer.name,
|
||||
'active': printer.active,
|
||||
'plug_ip': printer.plug_ip
|
||||
})
|
||||
|
||||
return {
|
||||
'success': True,
|
||||
'total_printers': len(all_printers),
|
||||
'locations': locations,
|
||||
'location_count': len(locations)
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Abrufen der Standorte: {str(e)}")
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Fehler: {str(e)}',
|
||||
'locations': {}
|
||||
}
|
||||
|
||||
# ===== STATUS UND STATISTIKEN =====
|
||||
|
||||
def get_printer_status_summary():
|
||||
"""
|
||||
Gibt eine Zusammenfassung des Drucker-Status zurück.
|
||||
|
||||
Returns:
|
||||
dict: Status-Zusammenfassung
|
||||
"""
|
||||
try:
|
||||
session = get_db_session()
|
||||
all_printers = session.query(Printer).all()
|
||||
session.close()
|
||||
|
||||
if not all_printers:
|
||||
return {
|
||||
'success': False,
|
||||
'message': 'Keine Drucker gefunden',
|
||||
'summary': {}
|
||||
}
|
||||
|
||||
active_count = sum(1 for p in all_printers if p.active)
|
||||
inactive_count = len(all_printers) - active_count
|
||||
|
||||
# Standort-Verteilung
|
||||
location_distribution = {}
|
||||
for printer in all_printers:
|
||||
location = printer.location or 'Unbekannt'
|
||||
location_distribution[location] = location_distribution.get(location, 0) + 1
|
||||
|
||||
return {
|
||||
'success': True,
|
||||
'summary': {
|
||||
'total_printers': len(all_printers),
|
||||
'active_printers': active_count,
|
||||
'inactive_printers': inactive_count,
|
||||
'locations': location_distribution,
|
||||
'last_updated': datetime.now().isoformat()
|
||||
}
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Abrufen der Status-Zusammenfassung: {str(e)}")
|
||||
return {
|
||||
'success': False,
|
||||
'message': f'Fehler: {str(e)}',
|
||||
'summary': {}
|
||||
}
|
||||
|
||||
# ===== CLI INTERFACE =====
|
||||
|
||||
if __name__ == "__main__":
|
||||
import sys
|
||||
|
||||
if len(sys.argv) > 1:
|
||||
command = sys.argv[1]
|
||||
|
||||
if command == "activate-all":
|
||||
result = aktiviere_alle_drucker()
|
||||
print(f"✅ {result['message']}")
|
||||
|
||||
elif command == "deactivate-all":
|
||||
result = deaktiviere_alle_drucker()
|
||||
print(f"✅ {result['message']}")
|
||||
|
||||
elif command == "update-locations":
|
||||
new_location = sys.argv[2] if len(sys.argv) > 2 else "Werk 040 - Berlin - TBA"
|
||||
result = update_printer_locations(new_location)
|
||||
print(f"✅ {result['message']}")
|
||||
|
||||
elif command == "locations":
|
||||
result = get_printer_locations()
|
||||
if result['success']:
|
||||
print("=== Drucker-Standorte ===")
|
||||
for location, printers in result['locations'].items():
|
||||
print(f"\n📍 {location} ({len(printers)} Drucker):")
|
||||
for printer in printers:
|
||||
status = "🟢" if printer['active'] else "🔴"
|
||||
print(f" {status} {printer['name']} (ID: {printer['id']}, IP: {printer['plug_ip']})")
|
||||
else:
|
||||
print(f"❌ {result['message']}")
|
||||
|
||||
elif command == "status":
|
||||
result = get_printer_status_summary()
|
||||
if result['success']:
|
||||
summary = result['summary']
|
||||
print("=== Drucker-Status ===")
|
||||
print(f"Gesamt: {summary['total_printers']}")
|
||||
print(f"Aktiv: {summary['active_printers']} 🟢")
|
||||
print(f"Inaktiv: {summary['inactive_printers']} 🔴")
|
||||
print(f"Standorte: {len(summary['locations'])}")
|
||||
print(f"Letzte Aktualisierung: {summary['last_updated']}")
|
||||
else:
|
||||
print(f"❌ {result['message']}")
|
||||
|
||||
else:
|
||||
print("Verfügbare Kommandos:")
|
||||
print(" activate-all - Aktiviert alle Drucker")
|
||||
print(" deactivate-all - Deaktiviert alle Drucker")
|
||||
print(" update-locations [STANDORT] - Aktualisiert alle Standorte")
|
||||
print(" locations - Zeigt Standort-Übersicht")
|
||||
print(" status - Zeigt Status-Zusammenfassung")
|
||||
else:
|
||||
print("Verwendung: python3.11 printer_utilities.py <command>")
|
||||
print("Verfügbare Kommandos: activate-all, deactivate-all, update-locations, locations, status")
|
||||
@ -1,497 +0,0 @@
|
||||
"""
|
||||
Queue Manager für die Verwaltung von Druckjobs in Warteschlangen.
|
||||
Überwacht offline Drucker und aktiviert Jobs automatisch.
|
||||
"""
|
||||
|
||||
import threading
|
||||
import time
|
||||
import logging
|
||||
import subprocess
|
||||
import os
|
||||
import requests
|
||||
import signal
|
||||
import atexit
|
||||
from datetime import datetime, timedelta
|
||||
from typing import List, Dict, Optional, Tuple
|
||||
from contextlib import contextmanager
|
||||
|
||||
from models import get_db_session, Job, Printer, User, Notification
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
# Windows-spezifische Imports
|
||||
if os.name == 'nt':
|
||||
try:
|
||||
from utils.windows_fixes import get_windows_thread_manager
|
||||
except ImportError:
|
||||
get_windows_thread_manager = None
|
||||
else:
|
||||
get_windows_thread_manager = None
|
||||
|
||||
# Logger für Queue-Manager
|
||||
queue_logger = get_logger("queue_manager")
|
||||
|
||||
def check_printer_status(ip_address: str, timeout: int = 5) -> Tuple[str, bool]:
|
||||
"""
|
||||
Vereinfachte Drucker-Status-Prüfung für den Queue Manager.
|
||||
|
||||
Args:
|
||||
ip_address: IP-Adresse der Drucker-Steckdose
|
||||
timeout: Timeout in Sekunden (Standard: 5)
|
||||
|
||||
Returns:
|
||||
Tuple[str, bool]: (Status, Aktiv) - Status ist "online" oder "offline", Aktiv ist True/False
|
||||
"""
|
||||
if not ip_address or ip_address.strip() == "":
|
||||
return "offline", False
|
||||
|
||||
try:
|
||||
# Ping-Test um Erreichbarkeit zu prüfen
|
||||
if os.name == 'nt': # Windows
|
||||
cmd = ['ping', '-n', '1', '-w', str(timeout * 1000), ip_address.strip()]
|
||||
else: # Unix/Linux/macOS
|
||||
cmd = ['ping', '-c', '1', '-W', str(timeout), ip_address.strip()]
|
||||
|
||||
result = subprocess.run(
|
||||
cmd,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=timeout + 1,
|
||||
encoding='utf-8',
|
||||
errors='replace'
|
||||
)
|
||||
|
||||
# Wenn Ping erfolgreich ist, als online betrachten
|
||||
if result.returncode == 0:
|
||||
queue_logger.debug(f"✅ Drucker {ip_address} ist erreichbar (Ping erfolgreich)")
|
||||
return "online", True
|
||||
else:
|
||||
queue_logger.debug(f"❌ Drucker {ip_address} nicht erreichbar (Ping fehlgeschlagen)")
|
||||
return "offline", False
|
||||
|
||||
except subprocess.TimeoutExpired:
|
||||
queue_logger.warning(f"⏱️ Ping-Timeout für Drucker {ip_address} nach {timeout} Sekunden")
|
||||
return "offline", False
|
||||
except Exception as e:
|
||||
queue_logger.error(f"❌ Fehler beim Status-Check für Drucker {ip_address}: {str(e)}")
|
||||
return "offline", False
|
||||
|
||||
class PrinterQueueManager:
|
||||
"""
|
||||
Verwaltet die Warteschlangen für offline Drucker und überwacht deren Status.
|
||||
Verbesserte Version mit ordnungsgemäßem Thread-Management für Windows.
|
||||
"""
|
||||
|
||||
def __init__(self, register_signal_handlers: bool = True):
|
||||
self.is_running = False
|
||||
self.monitor_thread = None
|
||||
self.shutdown_event = threading.Event() # Sauberes Shutdown-Signal
|
||||
self.check_interval = 120 # 2 Minuten zwischen Status-Checks
|
||||
self.last_status_cache = {} # Cache für letzten bekannten Status
|
||||
self.notification_cooldown = {} # Verhindert Spam-Benachrichtigungen
|
||||
self._lock = threading.Lock() # Thread-Sicherheit
|
||||
self._signal_handlers_registered = False
|
||||
|
||||
# Signal-Handler nur registrieren wenn explizit gewünscht
|
||||
# (Verhindert Interferenzen mit zentralem Shutdown-Manager)
|
||||
if register_signal_handlers and os.name == 'nt':
|
||||
self._register_signal_handlers()
|
||||
|
||||
def _register_signal_handlers(self):
|
||||
"""Windows-spezifische Signal-Handler registrieren (nur wenn gewünscht)"""
|
||||
if self._signal_handlers_registered:
|
||||
return
|
||||
|
||||
try:
|
||||
# Prüfe ob bereits zentrale Signal-Handler existieren
|
||||
try:
|
||||
from utils.shutdown_manager import is_shutdown_requested
|
||||
if is_shutdown_requested is not None:
|
||||
queue_logger.info("🔄 Zentrale Signal-Handler erkannt - deaktiviere lokale Handler")
|
||||
return
|
||||
except ImportError:
|
||||
pass # Kein zentraler Manager verfügbar, verwende lokale Handler
|
||||
|
||||
signal.signal(signal.SIGINT, self._signal_handler)
|
||||
signal.signal(signal.SIGTERM, self._signal_handler)
|
||||
self._signal_handlers_registered = True
|
||||
queue_logger.debug("✅ Lokale Signal-Handler für Queue Manager registriert")
|
||||
|
||||
except Exception as e:
|
||||
queue_logger.warning(f"⚠️ Lokale Signal-Handler konnten nicht registriert werden: {e}")
|
||||
|
||||
def _signal_handler(self, signum, frame):
|
||||
"""Signal-Handler für ordnungsgemäßes Shutdown (nur als Fallback)."""
|
||||
queue_logger.warning(f"🛑 Signal {signum} empfangen - stoppe Queue Manager...")
|
||||
self.stop()
|
||||
|
||||
def start(self):
|
||||
"""Startet den Queue-Manager mit verbessertem Shutdown-Handling."""
|
||||
with self._lock:
|
||||
if self.is_running:
|
||||
queue_logger.warning("Queue-Manager läuft bereits")
|
||||
return self
|
||||
|
||||
queue_logger.info("🚀 Starte Printer Queue Manager...")
|
||||
self.is_running = True
|
||||
self.shutdown_event.clear()
|
||||
|
||||
# Monitor-Thread mit Daemon-Flag für automatische Beendigung
|
||||
self.monitor_thread = threading.Thread(
|
||||
target=self._monitor_loop,
|
||||
name="PrinterQueueMonitor",
|
||||
daemon=True # Automatische Beendigung bei Programm-Ende
|
||||
)
|
||||
self.monitor_thread.start()
|
||||
|
||||
queue_logger.info("✅ Printer Queue Manager gestartet")
|
||||
return self
|
||||
|
||||
def stop(self):
|
||||
"""Stoppt den Queue-Manager ordnungsgemäß mit verbessertem Timeout-Handling."""
|
||||
with self._lock:
|
||||
if not self.is_running:
|
||||
queue_logger.debug("Queue-Manager ist bereits gestoppt")
|
||||
return
|
||||
|
||||
queue_logger.info("🔄 Beende Queue Manager...")
|
||||
self.is_running = False
|
||||
self.shutdown_event.set()
|
||||
|
||||
if self.monitor_thread and self.monitor_thread.is_alive():
|
||||
queue_logger.debug("⏳ Warte auf Thread-Beendigung...")
|
||||
|
||||
# Verbessertes Timeout-Handling
|
||||
try:
|
||||
self.monitor_thread.join(timeout=5.0) # Reduziertes Timeout
|
||||
|
||||
if self.monitor_thread.is_alive():
|
||||
queue_logger.warning("⚠️ Thread konnte nicht in 5s beendet werden - setze als Daemon")
|
||||
# Thread als Daemon markieren für automatische Beendigung
|
||||
self.monitor_thread.daemon = True
|
||||
else:
|
||||
queue_logger.info("✅ Monitor-Thread erfolgreich beendet")
|
||||
|
||||
except Exception as e:
|
||||
queue_logger.error(f"❌ Fehler beim Thread-Join: {e}")
|
||||
|
||||
self.monitor_thread = None
|
||||
queue_logger.info("❌ Printer Queue Manager gestoppt")
|
||||
|
||||
def _monitor_loop(self):
|
||||
"""Hauptschleife für die Überwachung der Drucker mit verbessertem Shutdown-Handling."""
|
||||
queue_logger.info(f"🔄 Queue-Überwachung gestartet (Intervall: {self.check_interval} Sekunden)")
|
||||
|
||||
while self.is_running and not self.shutdown_event.is_set():
|
||||
try:
|
||||
# Prüfe auf zentrales Shutdown-Signal
|
||||
try:
|
||||
from utils.shutdown_manager import is_shutdown_requested
|
||||
if is_shutdown_requested():
|
||||
queue_logger.info("🛑 Zentrales Shutdown-Signal empfangen - beende Monitor-Loop")
|
||||
break
|
||||
except ImportError:
|
||||
pass # Kein zentraler Manager verfügbar
|
||||
|
||||
self._check_waiting_jobs()
|
||||
|
||||
# Verwende Event.wait() statt time.sleep() für unterbrechbares Warten
|
||||
if self.shutdown_event.wait(timeout=self.check_interval):
|
||||
# Shutdown-Signal erhalten
|
||||
queue_logger.info("🛑 Shutdown-Signal empfangen - beende Monitor-Loop")
|
||||
break
|
||||
|
||||
except Exception as e:
|
||||
queue_logger.error(f"❌ Fehler in Monitor-Schleife: {str(e)}")
|
||||
# Kürzere Wartezeit bei Fehlern, aber auch unterbrechbar
|
||||
if self.shutdown_event.wait(timeout=30):
|
||||
break
|
||||
|
||||
queue_logger.info("🔚 Monitor-Loop beendet")
|
||||
|
||||
def _check_waiting_jobs(self):
|
||||
"""Überprüft alle wartenden Jobs und aktiviert sie bei verfügbaren Druckern."""
|
||||
if self.shutdown_event.is_set():
|
||||
return
|
||||
|
||||
db_session = get_db_session()
|
||||
|
||||
try:
|
||||
# Alle wartenden Jobs abrufen
|
||||
waiting_jobs = db_session.query(Job).filter(
|
||||
Job.status == "waiting_for_printer"
|
||||
).all()
|
||||
|
||||
if not waiting_jobs:
|
||||
return
|
||||
|
||||
queue_logger.info(f"🔍 Überprüfe {len(waiting_jobs)} wartende Jobs...")
|
||||
|
||||
activated_jobs = []
|
||||
|
||||
for job in waiting_jobs:
|
||||
# Shutdown-Check zwischen Jobs
|
||||
if self.shutdown_event.is_set():
|
||||
break
|
||||
|
||||
# Drucker-Status prüfen
|
||||
printer = db_session.get(Printer, job.printer_id)
|
||||
if not printer:
|
||||
continue
|
||||
|
||||
# Status-Check mit Cache-Optimierung
|
||||
printer_key = f"printer_{printer.id}"
|
||||
current_status = None
|
||||
|
||||
try:
|
||||
if printer.plug_ip:
|
||||
status, active = check_printer_status(printer.plug_ip, timeout=5)
|
||||
current_status = "online" if (status == "online" and active) else "offline"
|
||||
else:
|
||||
current_status = "offline"
|
||||
|
||||
except Exception as e:
|
||||
queue_logger.warning(f"⚠️ Status-Check für Drucker {printer.name} fehlgeschlagen: {str(e)}")
|
||||
current_status = "offline"
|
||||
|
||||
# Prüfen, ob Drucker online geworden ist
|
||||
last_status = self.last_status_cache.get(printer_key, "offline")
|
||||
self.last_status_cache[printer_key] = current_status
|
||||
|
||||
if current_status == "online" and last_status == "offline":
|
||||
# Drucker ist online geworden!
|
||||
queue_logger.info(f"🟢 Drucker {printer.name} ist ONLINE geworden - aktiviere wartende Jobs")
|
||||
|
||||
# Job aktivieren
|
||||
job.status = "scheduled"
|
||||
printer.status = "available"
|
||||
printer.active = True
|
||||
printer.last_checked = datetime.now()
|
||||
|
||||
activated_jobs.append({
|
||||
"job": job,
|
||||
"printer": printer
|
||||
})
|
||||
|
||||
elif current_status == "online":
|
||||
# Drucker ist bereits online, Job kann aktiviert werden
|
||||
job.status = "scheduled"
|
||||
printer.status = "available"
|
||||
printer.active = True
|
||||
printer.last_checked = datetime.now()
|
||||
|
||||
activated_jobs.append({
|
||||
"job": job,
|
||||
"printer": printer
|
||||
})
|
||||
|
||||
else:
|
||||
# Drucker bleibt offline
|
||||
printer.status = "offline"
|
||||
printer.active = False
|
||||
printer.last_checked = datetime.now()
|
||||
|
||||
# Speichere alle Änderungen
|
||||
if activated_jobs:
|
||||
db_session.commit()
|
||||
queue_logger.info(f"✅ {len(activated_jobs)} Jobs erfolgreich aktiviert")
|
||||
|
||||
# Benachrichtigungen versenden (nur wenn nicht im Shutdown)
|
||||
if not self.shutdown_event.is_set():
|
||||
for item in activated_jobs:
|
||||
self._send_job_activation_notification(item["job"], item["printer"])
|
||||
else:
|
||||
# Auch offline-Status speichern
|
||||
db_session.commit()
|
||||
|
||||
except Exception as e:
|
||||
db_session.rollback()
|
||||
queue_logger.error(f"❌ Fehler beim Überprüfen wartender Jobs: {str(e)}")
|
||||
finally:
|
||||
db_session.close()
|
||||
|
||||
def _send_job_activation_notification(self, job: Job, printer: Printer):
|
||||
"""Sendet eine Benachrichtigung, wenn ein Job aktiviert wird."""
|
||||
if self.shutdown_event.is_set():
|
||||
return
|
||||
|
||||
try:
|
||||
# Cooldown prüfen (keine Spam-Benachrichtigungen)
|
||||
cooldown_key = f"job_{job.id}_activated"
|
||||
now = datetime.now()
|
||||
|
||||
if cooldown_key in self.notification_cooldown:
|
||||
last_notification = self.notification_cooldown[cooldown_key]
|
||||
if (now - last_notification).total_seconds() < 300: # 5 Minuten Cooldown
|
||||
return
|
||||
|
||||
self.notification_cooldown[cooldown_key] = now
|
||||
|
||||
# Benachrichtigung erstellen
|
||||
db_session = get_db_session()
|
||||
|
||||
try:
|
||||
user = db_session.get(User, job.user_id)
|
||||
if not user:
|
||||
return
|
||||
|
||||
notification = Notification(
|
||||
user_id=user.id,
|
||||
type="job_activated",
|
||||
payload={
|
||||
"job_id": job.id,
|
||||
"job_name": job.name,
|
||||
"printer_id": printer.id,
|
||||
"printer_name": printer.name,
|
||||
"start_time": job.start_at.isoformat() if job.start_at else None,
|
||||
"message": f"🎉 Gute Nachrichten! Drucker '{printer.name}' ist online. Ihr Job '{job.name}' wurde aktiviert und startet bald."
|
||||
}
|
||||
)
|
||||
|
||||
db_session.add(notification)
|
||||
db_session.commit()
|
||||
|
||||
queue_logger.info(f"📧 Benachrichtigung für User {user.name} gesendet: Job {job.name} aktiviert")
|
||||
|
||||
except Exception as e:
|
||||
db_session.rollback()
|
||||
queue_logger.error(f"❌ Fehler beim Erstellen der Benachrichtigung: {str(e)}")
|
||||
finally:
|
||||
db_session.close()
|
||||
|
||||
except Exception as e:
|
||||
queue_logger.error(f"❌ Fehler beim Senden der Aktivierungs-Benachrichtigung: {str(e)}")
|
||||
|
||||
def get_queue_status(self) -> Dict:
|
||||
"""Gibt den aktuellen Status der Warteschlangen zurück."""
|
||||
db_session = get_db_session()
|
||||
|
||||
try:
|
||||
# Wartende Jobs zählen
|
||||
waiting_jobs = db_session.query(Job).filter(
|
||||
Job.status == "waiting_for_printer"
|
||||
).count()
|
||||
|
||||
# Offline Drucker mit wartenden Jobs
|
||||
offline_printers_with_queue = db_session.query(Printer).join(Job).filter(
|
||||
Printer.status == "offline",
|
||||
Job.status == "waiting_for_printer"
|
||||
).distinct().count()
|
||||
|
||||
# Online Drucker
|
||||
online_printers = db_session.query(Printer).filter(
|
||||
Printer.status == "available"
|
||||
).count()
|
||||
|
||||
total_printers = db_session.query(Printer).count()
|
||||
|
||||
return {
|
||||
"waiting_jobs": waiting_jobs,
|
||||
"offline_printers_with_queue": offline_printers_with_queue,
|
||||
"online_printers": online_printers,
|
||||
"total_printers": total_printers,
|
||||
"queue_manager_running": self.is_running,
|
||||
"last_check": datetime.now().isoformat(),
|
||||
"check_interval_seconds": self.check_interval
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
queue_logger.error(f"❌ Fehler beim Abrufen des Queue-Status: {str(e)}")
|
||||
return {
|
||||
"error": str(e),
|
||||
"queue_manager_running": self.is_running
|
||||
}
|
||||
finally:
|
||||
db_session.close()
|
||||
|
||||
def is_healthy(self) -> bool:
|
||||
"""Prüft, ob der Queue Manager ordnungsgemäß läuft."""
|
||||
return (self.is_running and
|
||||
self.monitor_thread is not None and
|
||||
self.monitor_thread.is_alive() and
|
||||
not self.shutdown_event.is_set())
|
||||
|
||||
# Globale Instanz des Queue-Managers
|
||||
_queue_manager_instance = None
|
||||
_queue_manager_lock = threading.Lock()
|
||||
|
||||
def get_queue_manager() -> PrinterQueueManager:
|
||||
"""Gibt die globale Instanz des Queue-Managers zurück."""
|
||||
global _queue_manager_instance
|
||||
with _queue_manager_lock:
|
||||
if _queue_manager_instance is None:
|
||||
_queue_manager_instance = PrinterQueueManager()
|
||||
return _queue_manager_instance
|
||||
|
||||
def start_queue_manager():
|
||||
"""Startet den globalen Queue-Manager sicher und ohne Signal-Handler-Interferenzen."""
|
||||
global _queue_manager_instance
|
||||
with _queue_manager_lock:
|
||||
if _queue_manager_instance is not None:
|
||||
queue_logger.warning("Queue-Manager läuft bereits")
|
||||
return _queue_manager_instance
|
||||
|
||||
try:
|
||||
queue_logger.info("🚀 Initialisiere neuen Queue-Manager...")
|
||||
|
||||
# Prüfe ob zentraler Shutdown-Manager verfügbar ist
|
||||
register_signals = True
|
||||
try:
|
||||
from utils.shutdown_manager import is_shutdown_requested
|
||||
if is_shutdown_requested is not None:
|
||||
queue_logger.info("🔄 Zentrale Shutdown-Verwaltung erkannt - deaktiviere lokale Signal-Handler")
|
||||
register_signals = False
|
||||
except ImportError:
|
||||
queue_logger.debug("Kein zentraler Shutdown-Manager verfügbar - verwende lokale Signal-Handler")
|
||||
|
||||
# Erstelle Queue-Manager ohne Signal-Handler wenn zentraler Manager vorhanden
|
||||
_queue_manager_instance = PrinterQueueManager(register_signal_handlers=register_signals)
|
||||
_queue_manager_instance.start()
|
||||
|
||||
queue_logger.info("✅ Queue-Manager erfolgreich gestartet")
|
||||
return _queue_manager_instance
|
||||
|
||||
except Exception as e:
|
||||
queue_logger.error(f"❌ Fehler beim Starten des Queue-Managers: {str(e)}")
|
||||
_queue_manager_instance = None
|
||||
raise
|
||||
|
||||
def stop_queue_manager():
|
||||
"""Stoppt den globalen Queue-Manager definitiv und sicher."""
|
||||
global _queue_manager_instance
|
||||
with _queue_manager_lock:
|
||||
if _queue_manager_instance:
|
||||
try:
|
||||
queue_logger.info("🔄 Stoppe Queue-Manager...")
|
||||
|
||||
# Shutdown-Event setzen
|
||||
_queue_manager_instance.shutdown_event.set()
|
||||
|
||||
# Monitor-Thread beenden
|
||||
if (_queue_manager_instance.monitor_thread and
|
||||
_queue_manager_instance.monitor_thread.is_alive()):
|
||||
|
||||
queue_logger.info("⏳ Warte auf Monitor-Thread...")
|
||||
_queue_manager_instance.monitor_thread.join(timeout=5.0)
|
||||
|
||||
# Falls Thread nicht beendet wurde, forciere Beendigung
|
||||
if _queue_manager_instance.monitor_thread.is_alive():
|
||||
queue_logger.warning("⚠️ Monitor-Thread reagiert nicht - forciere Beendigung")
|
||||
# Thread als Daemon markieren für automatische Beendigung
|
||||
_queue_manager_instance.monitor_thread.daemon = True
|
||||
|
||||
# Status auf gestoppt setzen
|
||||
_queue_manager_instance.is_running = False
|
||||
|
||||
# Explizit stop() aufrufen
|
||||
_queue_manager_instance.stop()
|
||||
|
||||
queue_logger.info("✅ Queue-Manager erfolgreich gestoppt")
|
||||
|
||||
except Exception as e:
|
||||
queue_logger.error(f"❌ Fehler beim Stoppen des Queue-Managers: {str(e)}")
|
||||
finally:
|
||||
# Instanz definitiv auf None setzen
|
||||
_queue_manager_instance = None
|
||||
|
||||
# Automatisches Cleanup bei Prozess-Ende registrieren
|
||||
atexit.register(stop_queue_manager)
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,914 +0,0 @@
|
||||
"""
|
||||
Multi-Format-Report-Generator für das MYP-System
|
||||
===============================================
|
||||
|
||||
Dieses Modul stellt umfassende Report-Generierung in verschiedenen Formaten bereit:
|
||||
- PDF-Reports mit professionellem Layout
|
||||
- Excel-Reports mit Diagrammen und Formatierungen
|
||||
- CSV-Export für Datenanalyse
|
||||
- JSON-Export für API-Integration
|
||||
"""
|
||||
|
||||
import os
|
||||
import io
|
||||
import json
|
||||
import logging
|
||||
from datetime import datetime, timedelta
|
||||
from typing import Dict, List, Any, Optional, Union, BinaryIO
|
||||
from dataclasses import dataclass, asdict
|
||||
from abc import ABC, abstractmethod
|
||||
|
||||
# PDF-Generation
|
||||
try:
|
||||
from reportlab.lib import colors
|
||||
from reportlab.lib.pagesizes import A4, letter
|
||||
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
|
||||
from reportlab.lib.units import inch, cm
|
||||
from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer, Image, PageBreak
|
||||
from reportlab.graphics.shapes import Drawing
|
||||
from reportlab.graphics.charts.lineplots import LinePlot
|
||||
from reportlab.graphics.charts.barcharts import VerticalBarChart
|
||||
from reportlab.graphics.charts.piecharts import Pie
|
||||
from reportlab.lib.validators import Auto
|
||||
PDF_AVAILABLE = True
|
||||
except ImportError:
|
||||
PDF_AVAILABLE = False
|
||||
|
||||
# Excel-Generation
|
||||
try:
|
||||
import xlsxwriter
|
||||
from xlsxwriter.workbook import Workbook
|
||||
from xlsxwriter.worksheet import Worksheet
|
||||
EXCEL_AVAILABLE = True
|
||||
except ImportError:
|
||||
EXCEL_AVAILABLE = False
|
||||
|
||||
import csv
|
||||
from flask import make_response, jsonify
|
||||
|
||||
from utils.logging_config import get_logger
|
||||
from models import Job, User, Printer, Stats, GuestRequest, get_db_session
|
||||
|
||||
logger = get_logger("reports")
|
||||
|
||||
@dataclass
|
||||
class ReportConfig:
|
||||
"""Konfiguration für Report-Generierung"""
|
||||
title: str
|
||||
subtitle: str = ""
|
||||
author: str = "MYP System"
|
||||
date_range: tuple = None
|
||||
include_charts: bool = True
|
||||
include_summary: bool = True
|
||||
template: str = "standard"
|
||||
logo_path: str = None
|
||||
footer_text: str = "Generiert vom MYP-System"
|
||||
|
||||
@dataclass
|
||||
class ChartData:
|
||||
"""Daten für Diagramme"""
|
||||
chart_type: str # 'line', 'bar', 'pie'
|
||||
title: str
|
||||
data: List[Dict[str, Any]]
|
||||
labels: List[str] = None
|
||||
colors: List[str] = None
|
||||
|
||||
class BaseReportGenerator(ABC):
|
||||
"""Abstrakte Basis-Klasse für Report-Generatoren"""
|
||||
|
||||
def __init__(self, config: ReportConfig):
|
||||
self.config = config
|
||||
self.data = {}
|
||||
self.charts = []
|
||||
|
||||
@abstractmethod
|
||||
def generate(self, output_stream: BinaryIO) -> bool:
|
||||
"""Generiert den Report in den angegebenen Stream"""
|
||||
pass
|
||||
|
||||
def add_data_section(self, name: str, data: List[Dict[str, Any]], headers: List[str] = None):
|
||||
"""Fügt eine Datensektion hinzu"""
|
||||
self.data[name] = {
|
||||
'data': data,
|
||||
'headers': headers or (list(data[0].keys()) if data else [])
|
||||
}
|
||||
|
||||
def add_chart(self, chart: ChartData):
|
||||
"""Fügt ein Diagramm hinzu"""
|
||||
self.charts.append(chart)
|
||||
|
||||
class PDFReportGenerator(BaseReportGenerator):
|
||||
"""PDF-Report-Generator mit professionellem Layout"""
|
||||
|
||||
def __init__(self, config: ReportConfig):
|
||||
super().__init__(config)
|
||||
if not PDF_AVAILABLE:
|
||||
raise ImportError("ReportLab ist nicht installiert. Verwenden Sie: pip install reportlab")
|
||||
|
||||
self.doc = None
|
||||
self.story = []
|
||||
self.styles = getSampleStyleSheet()
|
||||
self._setup_custom_styles()
|
||||
|
||||
def _setup_custom_styles(self):
|
||||
"""Richtet benutzerdefinierte Styles ein"""
|
||||
# Titel-Style
|
||||
self.styles.add(ParagraphStyle(
|
||||
name='CustomTitle',
|
||||
parent=self.styles['Heading1'],
|
||||
fontSize=24,
|
||||
spaceAfter=30,
|
||||
alignment=1, # Zentriert
|
||||
textColor=colors.HexColor('#1f2937')
|
||||
))
|
||||
|
||||
# Untertitel-Style
|
||||
self.styles.add(ParagraphStyle(
|
||||
name='CustomSubtitle',
|
||||
parent=self.styles['Heading2'],
|
||||
fontSize=16,
|
||||
spaceAfter=20,
|
||||
alignment=1,
|
||||
textColor=colors.HexColor('#6b7280')
|
||||
))
|
||||
|
||||
# Sektions-Header
|
||||
self.styles.add(ParagraphStyle(
|
||||
name='SectionHeader',
|
||||
parent=self.styles['Heading2'],
|
||||
fontSize=14,
|
||||
spaceBefore=20,
|
||||
spaceAfter=10,
|
||||
textColor=colors.HexColor('#374151'),
|
||||
borderWidth=1,
|
||||
borderColor=colors.HexColor('#d1d5db'),
|
||||
borderPadding=5
|
||||
))
|
||||
|
||||
def generate(self, output_stream: BinaryIO) -> bool:
|
||||
"""Generiert PDF-Report"""
|
||||
try:
|
||||
self.doc = SimpleDocTemplate(
|
||||
output_stream,
|
||||
pagesize=A4,
|
||||
rightMargin=2*cm,
|
||||
leftMargin=2*cm,
|
||||
topMargin=2*cm,
|
||||
bottomMargin=2*cm
|
||||
)
|
||||
|
||||
self._build_header()
|
||||
self._build_summary()
|
||||
self._build_data_sections()
|
||||
self._build_charts()
|
||||
self._build_footer()
|
||||
|
||||
self.doc.build(self.story)
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei PDF-Generierung: {str(e)}")
|
||||
return False
|
||||
|
||||
def _build_header(self):
|
||||
"""Erstellt den Report-Header"""
|
||||
# Logo (falls vorhanden)
|
||||
if self.config.logo_path and os.path.exists(self.config.logo_path):
|
||||
try:
|
||||
logo = Image(self.config.logo_path, width=2*inch, height=1*inch)
|
||||
self.story.append(logo)
|
||||
self.story.append(Spacer(1, 0.2*inch))
|
||||
except Exception as e:
|
||||
logger.warning(f"Logo konnte nicht geladen werden: {str(e)}")
|
||||
|
||||
# Titel
|
||||
title = Paragraph(self.config.title, self.styles['CustomTitle'])
|
||||
self.story.append(title)
|
||||
|
||||
# Untertitel
|
||||
if self.config.subtitle:
|
||||
subtitle = Paragraph(self.config.subtitle, self.styles['CustomSubtitle'])
|
||||
self.story.append(subtitle)
|
||||
|
||||
# Generierungsdatum
|
||||
date_text = f"Generiert am: {datetime.now().strftime('%d.%m.%Y %H:%M')}"
|
||||
date_para = Paragraph(date_text, self.styles['Normal'])
|
||||
self.story.append(date_para)
|
||||
|
||||
# Autor
|
||||
author_text = f"Erstellt von: {self.config.author}"
|
||||
author_para = Paragraph(author_text, self.styles['Normal'])
|
||||
self.story.append(author_para)
|
||||
|
||||
self.story.append(Spacer(1, 0.3*inch))
|
||||
|
||||
def _build_summary(self):
|
||||
"""Erstellt die Zusammenfassung"""
|
||||
if not self.config.include_summary:
|
||||
return
|
||||
|
||||
header = Paragraph("Zusammenfassung", self.styles['SectionHeader'])
|
||||
self.story.append(header)
|
||||
|
||||
# Sammle Statistiken aus den Daten
|
||||
total_records = sum(len(section['data']) for section in self.data.values())
|
||||
|
||||
summary_data = [
|
||||
['Gesamtanzahl Datensätze', str(total_records)],
|
||||
['Berichtszeitraum', self._format_date_range()],
|
||||
['Anzahl Sektionen', str(len(self.data))],
|
||||
['Anzahl Diagramme', str(len(self.charts))]
|
||||
]
|
||||
|
||||
summary_table = Table(summary_data, colWidths=[4*inch, 2*inch])
|
||||
summary_table.setStyle(TableStyle([
|
||||
('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#f3f4f6')),
|
||||
('TEXTCOLOR', (0, 0), (-1, 0), colors.black),
|
||||
('ALIGN', (0, 0), (-1, -1), 'LEFT'),
|
||||
('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
|
||||
('FONTSIZE', (0, 0), (-1, 0), 12),
|
||||
('BOTTOMPADDING', (0, 0), (-1, 0), 12),
|
||||
('BACKGROUND', (0, 1), (-1, -1), colors.white),
|
||||
('GRID', (0, 0), (-1, -1), 1, colors.HexColor('#d1d5db'))
|
||||
]))
|
||||
|
||||
self.story.append(summary_table)
|
||||
self.story.append(Spacer(1, 0.2*inch))
|
||||
|
||||
def _build_data_sections(self):
|
||||
"""Erstellt die Datensektionen"""
|
||||
for section_name, section_data in self.data.items():
|
||||
# Sektions-Header
|
||||
header = Paragraph(section_name, self.styles['SectionHeader'])
|
||||
self.story.append(header)
|
||||
|
||||
# Daten-Tabelle
|
||||
table_data = [section_data['headers']]
|
||||
table_data.extend([
|
||||
[str(row.get(header, '')) for header in section_data['headers']]
|
||||
for row in section_data['data']
|
||||
])
|
||||
|
||||
# Spaltenbreiten berechnen
|
||||
col_count = len(section_data['headers'])
|
||||
col_width = (self.doc.width - 2*inch) / col_count
|
||||
col_widths = [col_width] * col_count
|
||||
|
||||
table = Table(table_data, colWidths=col_widths, repeatRows=1)
|
||||
table.setStyle(TableStyle([
|
||||
# Header-Styling
|
||||
('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#3b82f6')),
|
||||
('TEXTCOLOR', (0, 0), (-1, 0), colors.white),
|
||||
('ALIGN', (0, 0), (-1, -1), 'CENTER'),
|
||||
('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
|
||||
('FONTSIZE', (0, 0), (-1, 0), 10),
|
||||
|
||||
# Daten-Styling
|
||||
('FONTNAME', (0, 1), (-1, -1), 'Helvetica'),
|
||||
('FONTSIZE', (0, 1), (-1, -1), 9),
|
||||
('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.HexColor('#f9fafb')]),
|
||||
|
||||
# Rahmen
|
||||
('GRID', (0, 0), (-1, -1), 0.5, colors.HexColor('#d1d5db')),
|
||||
('VALIGN', (0, 0), (-1, -1), 'MIDDLE'),
|
||||
('LEFTPADDING', (0, 0), (-1, -1), 6),
|
||||
('RIGHTPADDING', (0, 0), (-1, -1), 6),
|
||||
('TOPPADDING', (0, 0), (-1, -1), 8),
|
||||
('BOTTOMPADDING', (0, 0), (-1, -1), 8),
|
||||
]))
|
||||
|
||||
self.story.append(table)
|
||||
self.story.append(Spacer(1, 0.2*inch))
|
||||
|
||||
# Seitenumbruch bei vielen Daten
|
||||
if len(section_data['data']) > 20:
|
||||
self.story.append(PageBreak())
|
||||
|
||||
def _build_charts(self):
|
||||
"""Erstellt die Diagramme"""
|
||||
if not self.config.include_charts or not self.charts:
|
||||
return
|
||||
|
||||
header = Paragraph("Diagramme", self.styles['SectionHeader'])
|
||||
self.story.append(header)
|
||||
|
||||
for chart in self.charts:
|
||||
chart_title = Paragraph(chart.title, self.styles['Heading3'])
|
||||
self.story.append(chart_title)
|
||||
|
||||
# Diagramm basierend auf Typ erstellen
|
||||
drawing = self._create_chart_drawing(chart)
|
||||
if drawing:
|
||||
self.story.append(drawing)
|
||||
self.story.append(Spacer(1, 0.2*inch))
|
||||
|
||||
def _create_chart_drawing(self, chart: ChartData) -> Optional[Any]:
|
||||
"""Erstellt ein Diagramm-Drawing"""
|
||||
# Überprüfe ob PDF-Bibliotheken verfügbar sind
|
||||
if not PDF_AVAILABLE:
|
||||
logger.warning("PDF-Bibliotheken nicht verfügbar - Diagramm wird übersprungen")
|
||||
return None
|
||||
|
||||
try:
|
||||
drawing = Drawing(400, 300)
|
||||
|
||||
if chart.chart_type == 'bar':
|
||||
bar_chart = VerticalBarChart()
|
||||
bar_chart.x = 50
|
||||
bar_chart.y = 50
|
||||
bar_chart.height = 200
|
||||
bar_chart.width = 300
|
||||
|
||||
# Daten vorbereiten
|
||||
values = [[item.get('value', 0) for item in chart.data]]
|
||||
categories = [item.get('label', f'Item {i}') for i, item in enumerate(chart.data)]
|
||||
|
||||
bar_chart.data = values
|
||||
bar_chart.categoryAxis.categoryNames = categories
|
||||
bar_chart.valueAxis.valueMin = 0
|
||||
|
||||
# Farben setzen
|
||||
if chart.colors:
|
||||
bar_chart.bars[0].fillColor = colors.HexColor(chart.colors[0] if chart.colors else '#3b82f6')
|
||||
|
||||
drawing.add(bar_chart)
|
||||
|
||||
elif chart.chart_type == 'pie':
|
||||
pie_chart = Pie()
|
||||
pie_chart.x = 150
|
||||
pie_chart.y = 100
|
||||
pie_chart.width = 100
|
||||
pie_chart.height = 100
|
||||
|
||||
# Daten vorbereiten
|
||||
pie_chart.data = [item.get('value', 0) for item in chart.data]
|
||||
pie_chart.labels = [item.get('label', f'Item {i}') for i, item in enumerate(chart.data)]
|
||||
|
||||
# Farben setzen
|
||||
if chart.colors:
|
||||
pie_chart.slices.fillColor = colors.HexColor(chart.colors[0] if chart.colors else '#3b82f6')
|
||||
|
||||
drawing.add(pie_chart)
|
||||
|
||||
return drawing
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Diagramm-Erstellung: {str(e)}")
|
||||
return None
|
||||
|
||||
def _build_footer(self):
|
||||
"""Erstellt den Report-Footer"""
|
||||
footer_text = self.config.footer_text
|
||||
footer = Paragraph(footer_text, self.styles['Normal'])
|
||||
self.story.append(Spacer(1, 0.3*inch))
|
||||
self.story.append(footer)
|
||||
|
||||
def _format_date_range(self) -> str:
|
||||
"""Formatiert den Datumsbereich"""
|
||||
if not self.config.date_range:
|
||||
return "Alle verfügbaren Daten"
|
||||
|
||||
start_date, end_date = self.config.date_range
|
||||
return f"{start_date.strftime('%d.%m.%Y')} - {end_date.strftime('%d.%m.%Y')}"
|
||||
|
||||
class ExcelReportGenerator(BaseReportGenerator):
|
||||
"""Excel-Report-Generator mit Diagrammen und Formatierungen"""
|
||||
|
||||
def __init__(self, config: ReportConfig):
|
||||
super().__init__(config)
|
||||
if not EXCEL_AVAILABLE:
|
||||
raise ImportError("XlsxWriter ist nicht installiert. Verwenden Sie: pip install xlsxwriter")
|
||||
|
||||
self.workbook = None
|
||||
self.formats = {}
|
||||
|
||||
def generate(self, output_stream: BinaryIO) -> bool:
|
||||
"""Generiert Excel-Report"""
|
||||
try:
|
||||
self.workbook = xlsxwriter.Workbook(output_stream, {'in_memory': True})
|
||||
self._setup_formats()
|
||||
|
||||
# Zusammenfassungs-Arbeitsblatt
|
||||
if self.config.include_summary:
|
||||
self._create_summary_worksheet()
|
||||
|
||||
# Daten-Arbeitsblätter
|
||||
for section_name, section_data in self.data.items():
|
||||
self._create_data_worksheet(section_name, section_data)
|
||||
|
||||
# Diagramm-Arbeitsblätter
|
||||
if self.config.include_charts and self.charts:
|
||||
self._create_charts_worksheet()
|
||||
|
||||
self.workbook.close()
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Excel-Generierung: {str(e)}")
|
||||
return False
|
||||
|
||||
def _setup_formats(self):
|
||||
"""Richtet Excel-Formate ein"""
|
||||
self.formats = {
|
||||
'title': self.workbook.add_format({
|
||||
'font_size': 18,
|
||||
'bold': True,
|
||||
'align': 'center',
|
||||
'bg_color': '#1f2937',
|
||||
'font_color': 'white',
|
||||
'border': 1
|
||||
}),
|
||||
'header': self.workbook.add_format({
|
||||
'font_size': 12,
|
||||
'bold': True,
|
||||
'bg_color': '#3b82f6',
|
||||
'font_color': 'white',
|
||||
'align': 'center',
|
||||
'border': 1
|
||||
}),
|
||||
'data': self.workbook.add_format({
|
||||
'align': 'center',
|
||||
'border': 1
|
||||
}),
|
||||
'data_alt': self.workbook.add_format({
|
||||
'align': 'center',
|
||||
'bg_color': '#f9fafb',
|
||||
'border': 1
|
||||
}),
|
||||
'number': self.workbook.add_format({
|
||||
'num_format': '#,##0',
|
||||
'align': 'right',
|
||||
'border': 1
|
||||
}),
|
||||
'currency': self.workbook.add_format({
|
||||
'num_format': '#,##0.00 €',
|
||||
'align': 'right',
|
||||
'border': 1
|
||||
}),
|
||||
'percentage': self.workbook.add_format({
|
||||
'num_format': '0.00%',
|
||||
'align': 'right',
|
||||
'border': 1
|
||||
}),
|
||||
'date': self.workbook.add_format({
|
||||
'num_format': 'dd.mm.yyyy',
|
||||
'align': 'center',
|
||||
'border': 1
|
||||
})
|
||||
}
|
||||
|
||||
def _create_summary_worksheet(self):
|
||||
"""Erstellt das Zusammenfassungs-Arbeitsblatt"""
|
||||
worksheet = self.workbook.add_worksheet('Zusammenfassung')
|
||||
|
||||
# Titel
|
||||
worksheet.merge_range('A1:E1', self.config.title, self.formats['title'])
|
||||
|
||||
# Untertitel
|
||||
if self.config.subtitle:
|
||||
worksheet.merge_range('A2:E2', self.config.subtitle, self.formats['header'])
|
||||
|
||||
# Metadaten
|
||||
row = 4
|
||||
metadata = [
|
||||
['Generiert am:', datetime.now().strftime('%d.%m.%Y %H:%M')],
|
||||
['Erstellt von:', self.config.author],
|
||||
['Berichtszeitraum:', self._format_date_range()],
|
||||
['Anzahl Sektionen:', str(len(self.data))],
|
||||
['Anzahl Diagramme:', str(len(self.charts))]
|
||||
]
|
||||
|
||||
for label, value in metadata:
|
||||
worksheet.write(row, 0, label, self.formats['header'])
|
||||
worksheet.write(row, 1, value, self.formats['data'])
|
||||
row += 1
|
||||
|
||||
# Statistiken pro Sektion
|
||||
row += 2
|
||||
worksheet.write(row, 0, 'Sektions-Übersicht:', self.formats['header'])
|
||||
row += 1
|
||||
|
||||
for section_name, section_data in self.data.items():
|
||||
worksheet.write(row, 0, section_name, self.formats['data'])
|
||||
worksheet.write(row, 1, len(section_data['data']), self.formats['number'])
|
||||
row += 1
|
||||
|
||||
# Spaltenbreiten anpassen
|
||||
worksheet.set_column('A:A', 25)
|
||||
worksheet.set_column('B:B', 20)
|
||||
|
||||
def _create_data_worksheet(self, section_name: str, section_data: Dict[str, Any]):
|
||||
"""Erstellt ein Daten-Arbeitsblatt"""
|
||||
# Ungültige Zeichen für Arbeitsblatt-Namen ersetzen
|
||||
safe_name = ''.join(c for c in section_name if c.isalnum() or c in ' -_')[:31]
|
||||
worksheet = self.workbook.add_worksheet(safe_name)
|
||||
|
||||
# Header schreiben
|
||||
headers = section_data['headers']
|
||||
for col, header in enumerate(headers):
|
||||
worksheet.write(0, col, header, self.formats['header'])
|
||||
|
||||
# Daten schreiben
|
||||
for row_idx, row_data in enumerate(section_data['data'], start=1):
|
||||
for col_idx, header in enumerate(headers):
|
||||
value = row_data.get(header, '')
|
||||
|
||||
# Format basierend auf Datentyp wählen
|
||||
cell_format = self._get_cell_format(value, row_idx)
|
||||
worksheet.write(row_idx, col_idx, value, cell_format)
|
||||
|
||||
# Autofilter hinzufügen
|
||||
if section_data['data']:
|
||||
worksheet.autofilter(0, 0, len(section_data['data']), len(headers) - 1)
|
||||
|
||||
# Spaltenbreiten anpassen
|
||||
for col_idx, header in enumerate(headers):
|
||||
max_length = max(
|
||||
len(str(header)),
|
||||
max(len(str(row.get(header, ''))) for row in section_data['data']) if section_data['data'] else 0
|
||||
)
|
||||
worksheet.set_column(col_idx, col_idx, min(max_length + 2, 50))
|
||||
|
||||
def _create_charts_worksheet(self):
|
||||
"""Erstellt das Diagramm-Arbeitsblatt"""
|
||||
worksheet = self.workbook.add_worksheet('Diagramme')
|
||||
|
||||
row = 0
|
||||
for chart_idx, chart_data in enumerate(self.charts):
|
||||
# Diagramm-Titel
|
||||
worksheet.write(row, 0, chart_data.title, self.formats['header'])
|
||||
row += 2
|
||||
|
||||
# Daten für Diagramm vorbereiten
|
||||
data_worksheet_name = f'Chart_Data_{chart_idx}'
|
||||
data_worksheet = self.workbook.add_worksheet(data_worksheet_name)
|
||||
|
||||
# Daten ins Data-Arbeitsblatt schreiben
|
||||
labels = [item.get('label', f'Item {i}') for i, item in enumerate(chart_data.data)]
|
||||
values = [item.get('value', 0) for item in chart_data.data]
|
||||
|
||||
data_worksheet.write_column('A1', ['Label'] + labels)
|
||||
data_worksheet.write_column('B1', ['Value'] + values)
|
||||
|
||||
# Excel-Diagramm erstellen
|
||||
if chart_data.chart_type == 'bar':
|
||||
chart = self.workbook.add_chart({'type': 'column'})
|
||||
elif chart_data.chart_type == 'line':
|
||||
chart = self.workbook.add_chart({'type': 'line'})
|
||||
elif chart_data.chart_type == 'pie':
|
||||
chart = self.workbook.add_chart({'type': 'pie'})
|
||||
else:
|
||||
chart = self.workbook.add_chart({'type': 'column'})
|
||||
|
||||
# Datenreihe hinzufügen
|
||||
chart.add_series({
|
||||
'name': chart_data.title,
|
||||
'categories': [data_worksheet_name, 1, 0, len(labels), 0],
|
||||
'values': [data_worksheet_name, 1, 1, len(values), 1],
|
||||
})
|
||||
|
||||
chart.set_title({'name': chart_data.title})
|
||||
chart.set_x_axis({'name': 'Kategorien'})
|
||||
chart.set_y_axis({'name': 'Werte'})
|
||||
|
||||
# Diagramm ins Arbeitsblatt einfügen
|
||||
worksheet.insert_chart(row, 0, chart)
|
||||
row += 15 # Platz für nächstes Diagramm
|
||||
|
||||
def _get_cell_format(self, value: Any, row_idx: int):
|
||||
"""Bestimmt das Zellformat basierend auf dem Wert"""
|
||||
# Alternierende Zeilenfarben
|
||||
base_format = self.formats['data'] if row_idx % 2 == 1 else self.formats['data_alt']
|
||||
|
||||
# Spezielle Formate für Zahlen, Daten, etc.
|
||||
if isinstance(value, (int, float)):
|
||||
return self.formats['number']
|
||||
elif isinstance(value, datetime):
|
||||
return self.formats['date']
|
||||
elif isinstance(value, str) and value.endswith('%'):
|
||||
return self.formats['percentage']
|
||||
elif isinstance(value, str) and '€' in value:
|
||||
return self.formats['currency']
|
||||
|
||||
return base_format
|
||||
|
||||
def _format_date_range(self) -> str:
|
||||
"""Formatiert den Datumsbereich"""
|
||||
if not self.config.date_range:
|
||||
return "Alle verfügbaren Daten"
|
||||
|
||||
start_date, end_date = self.config.date_range
|
||||
return f"{start_date.strftime('%d.%m.%Y')} - {end_date.strftime('%d.%m.%Y')}"
|
||||
|
||||
class CSVReportGenerator(BaseReportGenerator):
|
||||
"""CSV-Report-Generator für Datenanalyse"""
|
||||
|
||||
def generate(self, output_stream: BinaryIO) -> bool:
|
||||
"""Generiert CSV-Report"""
|
||||
try:
|
||||
# Text-Stream für CSV-Writer
|
||||
text_stream = io.TextIOWrapper(output_stream, encoding='utf-8-sig', newline='')
|
||||
writer = csv.writer(text_stream, delimiter=';', quoting=csv.QUOTE_MINIMAL)
|
||||
|
||||
# Header mit Metadaten
|
||||
writer.writerow([f'# {self.config.title}'])
|
||||
writer.writerow([f'# Generiert am: {datetime.now().strftime("%d.%m.%Y %H:%M")}'])
|
||||
writer.writerow([f'# Erstellt von: {self.config.author}'])
|
||||
writer.writerow(['']) # Leerzeile
|
||||
|
||||
# Daten-Sektionen
|
||||
for section_name, section_data in self.data.items():
|
||||
writer.writerow([f'# Sektion: {section_name}'])
|
||||
|
||||
# Headers
|
||||
writer.writerow(section_data['headers'])
|
||||
|
||||
# Daten
|
||||
for row in section_data['data']:
|
||||
csv_row = [str(row.get(header, '')) for header in section_data['headers']]
|
||||
writer.writerow(csv_row)
|
||||
|
||||
writer.writerow(['']) # Leerzeile zwischen Sektionen
|
||||
|
||||
text_stream.flush()
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei CSV-Generierung: {str(e)}")
|
||||
return False
|
||||
|
||||
class JSONReportGenerator(BaseReportGenerator):
|
||||
"""JSON-Report-Generator für API-Integration"""
|
||||
|
||||
def generate(self, output_stream: BinaryIO) -> bool:
|
||||
"""Generiert JSON-Report"""
|
||||
try:
|
||||
report_data = {
|
||||
'metadata': {
|
||||
'title': self.config.title,
|
||||
'subtitle': self.config.subtitle,
|
||||
'author': self.config.author,
|
||||
'generated_at': datetime.now().isoformat(),
|
||||
'date_range': {
|
||||
'start': self.config.date_range[0].isoformat() if self.config.date_range else None,
|
||||
'end': self.config.date_range[1].isoformat() if self.config.date_range else None
|
||||
} if self.config.date_range else None
|
||||
},
|
||||
'data': self.data,
|
||||
'charts': [asdict(chart) for chart in self.charts] if self.charts else []
|
||||
}
|
||||
|
||||
json_str = json.dumps(report_data, ensure_ascii=False, indent=2, default=str)
|
||||
output_stream.write(json_str.encode('utf-8'))
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei JSON-Generierung: {str(e)}")
|
||||
return False
|
||||
|
||||
class ReportFactory:
|
||||
"""Factory für Report-Generatoren"""
|
||||
|
||||
GENERATORS = {
|
||||
'pdf': PDFReportGenerator,
|
||||
'excel': ExcelReportGenerator,
|
||||
'xlsx': ExcelReportGenerator,
|
||||
'csv': CSVReportGenerator,
|
||||
'json': JSONReportGenerator
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def create_generator(cls, format_type: str, config: ReportConfig) -> BaseReportGenerator:
|
||||
"""Erstellt einen Report-Generator für das angegebene Format"""
|
||||
format_type = format_type.lower()
|
||||
|
||||
if format_type not in cls.GENERATORS:
|
||||
raise ValueError(f"Unbekanntes Report-Format: {format_type}")
|
||||
|
||||
generator_class = cls.GENERATORS[format_type]
|
||||
return generator_class(config)
|
||||
|
||||
@classmethod
|
||||
def get_available_formats(cls) -> List[str]:
|
||||
"""Gibt verfügbare Report-Formate zurück"""
|
||||
available = []
|
||||
|
||||
for format_type, generator_class in cls.GENERATORS.items():
|
||||
try:
|
||||
# Test ob Generator funktioniert
|
||||
if format_type in ['pdf'] and not PDF_AVAILABLE:
|
||||
continue
|
||||
elif format_type in ['excel', 'xlsx'] and not EXCEL_AVAILABLE:
|
||||
continue
|
||||
|
||||
available.append(format_type)
|
||||
except ImportError:
|
||||
continue
|
||||
|
||||
return available
|
||||
|
||||
# Vordefinierte Report-Templates
|
||||
class JobReportBuilder:
|
||||
"""Builder für Job-Reports"""
|
||||
|
||||
@staticmethod
|
||||
def build_jobs_report(
|
||||
start_date: datetime = None,
|
||||
end_date: datetime = None,
|
||||
user_id: int = None,
|
||||
printer_id: int = None,
|
||||
include_completed: bool = True,
|
||||
include_cancelled: bool = False
|
||||
) -> Dict[str, Any]:
|
||||
"""Erstellt Job-Report-Daten"""
|
||||
|
||||
with get_db_session() as db_session:
|
||||
query = db_session.query(Job)
|
||||
|
||||
# Filter anwenden
|
||||
if start_date:
|
||||
query = query.filter(Job.created_at >= start_date)
|
||||
if end_date:
|
||||
query = query.filter(Job.created_at <= end_date)
|
||||
if user_id:
|
||||
query = query.filter(Job.user_id == user_id)
|
||||
if printer_id:
|
||||
query = query.filter(Job.printer_id == printer_id)
|
||||
|
||||
status_filters = []
|
||||
if include_completed:
|
||||
status_filters.append('finished')
|
||||
if include_cancelled:
|
||||
status_filters.append('cancelled')
|
||||
if not include_cancelled and not include_completed:
|
||||
status_filters = ['scheduled', 'running', 'paused']
|
||||
|
||||
if status_filters:
|
||||
query = query.filter(Job.status.in_(status_filters))
|
||||
|
||||
jobs = query.all()
|
||||
|
||||
# Daten vorbereiten
|
||||
job_data = []
|
||||
for job in jobs:
|
||||
job_data.append({
|
||||
'ID': job.id,
|
||||
'Name': job.name,
|
||||
'Benutzer': job.user.name if job.user else 'Unbekannt',
|
||||
'Drucker': job.printer.name if job.printer else 'Unbekannt',
|
||||
'Status': job.status,
|
||||
'Erstellt': job.created_at.strftime('%d.%m.%Y %H:%M') if job.created_at else '',
|
||||
'Gestartet': job.start_at.strftime('%d.%m.%Y %H:%M') if job.start_at else '',
|
||||
'Beendet': job.end_at.strftime('%d.%m.%Y %H:%M') if job.end_at else '',
|
||||
'Dauer (Min)': job.duration_minutes or 0,
|
||||
'Material (g)': job.material_used or 0,
|
||||
'Beschreibung': job.description or ''
|
||||
})
|
||||
|
||||
return {
|
||||
'data': job_data,
|
||||
'headers': ['ID', 'Name', 'Benutzer', 'Drucker', 'Status', 'Erstellt', 'Gestartet', 'Beendet', 'Dauer (Min)', 'Material (g)', 'Beschreibung']
|
||||
}
|
||||
|
||||
class UserReportBuilder:
|
||||
"""Builder für Benutzer-Reports"""
|
||||
|
||||
@staticmethod
|
||||
def build_users_report(include_inactive: bool = False) -> Dict[str, Any]:
|
||||
"""Erstellt Benutzer-Report-Daten"""
|
||||
|
||||
with get_db_session() as db_session:
|
||||
query = db_session.query(User)
|
||||
|
||||
if not include_inactive:
|
||||
query = query.filter(User.active == True)
|
||||
|
||||
users = query.all()
|
||||
|
||||
# Daten vorbereiten
|
||||
user_data = []
|
||||
for user in users:
|
||||
user_data.append({
|
||||
'ID': user.id,
|
||||
'Name': user.name,
|
||||
'E-Mail': user.email,
|
||||
'Benutzername': user.username,
|
||||
'Rolle': user.role,
|
||||
'Aktiv': 'Ja' if user.active else 'Nein',
|
||||
'Abteilung': user.department or '',
|
||||
'Position': user.position or '',
|
||||
'Erstellt': user.created_at.strftime('%d.%m.%Y') if user.created_at else '',
|
||||
'Letzter Login': user.last_login.strftime('%d.%m.%Y %H:%M') if user.last_login else 'Nie'
|
||||
})
|
||||
|
||||
return {
|
||||
'data': user_data,
|
||||
'headers': ['ID', 'Name', 'E-Mail', 'Benutzername', 'Rolle', 'Aktiv', 'Abteilung', 'Position', 'Erstellt', 'Letzter Login']
|
||||
}
|
||||
|
||||
class PrinterReportBuilder:
|
||||
"""Builder für Drucker-Reports"""
|
||||
|
||||
@staticmethod
|
||||
def build_printers_report(include_inactive: bool = False) -> Dict[str, Any]:
|
||||
"""Erstellt Drucker-Report-Daten"""
|
||||
|
||||
with get_db_session() as db_session:
|
||||
query = db_session.query(Printer)
|
||||
|
||||
if not include_inactive:
|
||||
query = query.filter(Printer.active == True)
|
||||
|
||||
printers = query.all()
|
||||
|
||||
# Daten vorbereiten
|
||||
printer_data = []
|
||||
for printer in printers:
|
||||
printer_data.append({
|
||||
'ID': printer.id,
|
||||
'Name': printer.name,
|
||||
'Modell': printer.model or '',
|
||||
'Standort': printer.location or '',
|
||||
'IP-Adresse': printer.ip_address or '',
|
||||
'MAC-Adresse': printer.mac_address,
|
||||
'Plug-IP': printer.plug_ip,
|
||||
'Status': printer.status,
|
||||
'Aktiv': 'Ja' if printer.active else 'Nein',
|
||||
'Erstellt': printer.created_at.strftime('%d.%m.%Y') if printer.created_at else '',
|
||||
'Letzte Prüfung': printer.last_checked.strftime('%d.%m.%Y %H:%M') if printer.last_checked else 'Nie'
|
||||
})
|
||||
|
||||
return {
|
||||
'data': printer_data,
|
||||
'headers': ['ID', 'Name', 'Modell', 'Standort', 'IP-Adresse', 'MAC-Adresse', 'Plug-IP', 'Status', 'Aktiv', 'Erstellt', 'Letzte Prüfung']
|
||||
}
|
||||
|
||||
def generate_comprehensive_report(
|
||||
format_type: str,
|
||||
start_date: datetime = None,
|
||||
end_date: datetime = None,
|
||||
include_jobs: bool = True,
|
||||
include_users: bool = True,
|
||||
include_printers: bool = True,
|
||||
user_id: int = None
|
||||
) -> bytes:
|
||||
"""Generiert einen umfassenden System-Report"""
|
||||
|
||||
# Konfiguration
|
||||
config = ReportConfig(
|
||||
title="MYP System Report",
|
||||
subtitle="Umfassende Systemübersicht",
|
||||
author="MYP System",
|
||||
date_range=(start_date, end_date) if start_date and end_date else None,
|
||||
include_charts=True,
|
||||
include_summary=True
|
||||
)
|
||||
|
||||
# Generator erstellen
|
||||
generator = ReportFactory.create_generator(format_type, config)
|
||||
|
||||
# Daten hinzufügen
|
||||
if include_jobs:
|
||||
job_data = JobReportBuilder.build_jobs_report(
|
||||
start_date=start_date,
|
||||
end_date=end_date,
|
||||
user_id=user_id
|
||||
)
|
||||
generator.add_data_section("Jobs", job_data['data'], job_data['headers'])
|
||||
|
||||
# Job-Status-Diagramm
|
||||
status_counts = {}
|
||||
for job in job_data['data']:
|
||||
status = job['Status']
|
||||
status_counts[status] = status_counts.get(status, 0) + 1
|
||||
|
||||
chart_data = ChartData(
|
||||
chart_type='pie',
|
||||
title='Job-Status-Verteilung',
|
||||
data=[{'label': status, 'value': count} for status, count in status_counts.items()]
|
||||
)
|
||||
generator.add_chart(chart_data)
|
||||
|
||||
if include_users:
|
||||
user_data = UserReportBuilder.build_users_report()
|
||||
generator.add_data_section("Benutzer", user_data['data'], user_data['headers'])
|
||||
|
||||
if include_printers:
|
||||
printer_data = PrinterReportBuilder.build_printers_report()
|
||||
generator.add_data_section("Drucker", printer_data['data'], printer_data['headers'])
|
||||
|
||||
# Report generieren
|
||||
output = io.BytesIO()
|
||||
success = generator.generate(output)
|
||||
|
||||
if success:
|
||||
output.seek(0)
|
||||
return output.getvalue()
|
||||
else:
|
||||
raise Exception("Report-Generierung fehlgeschlagen")
|
||||
|
||||
# Zusätzliche Abhängigkeiten zu requirements.txt hinzufügen
|
||||
ADDITIONAL_REQUIREMENTS = [
|
||||
"reportlab>=4.0.0",
|
||||
"xlsxwriter>=3.0.0"
|
||||
]
|
||||
267
backend/utils/script_collection.py
Normal file
267
backend/utils/script_collection.py
Normal file
@ -0,0 +1,267 @@
|
||||
#!/usr/bin/env python3.11
|
||||
"""
|
||||
Script Collection - ALLERLETZTE MEGA-KONSOLIDIERUNG
|
||||
==================================================
|
||||
|
||||
Migration Information:
|
||||
- Ursprünglich: ALLE test_*.py, add_*.py, create_*.py, setup_*.py,
|
||||
update_*.py, migrate_*.py, fix_*.py Scripts
|
||||
- Konsolidiert am: 2025-06-09
|
||||
- Funktionalitäten: Testing, Setup, Fixes, Migrations
|
||||
- Breaking Changes: Keine
|
||||
|
||||
ALLERLETZTE MEGA-KONSOLIDIERUNG für Projektarbeit MYP
|
||||
Author: MYP Team - Till Tomczak
|
||||
Ziel: ALLE Scripts in EINER Datei!
|
||||
"""
|
||||
|
||||
import os
|
||||
from datetime import datetime
|
||||
from typing import Dict, Any, List
|
||||
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
# Logger
|
||||
script_logger = get_logger("script_collection")
|
||||
|
||||
# ===== TEST SCRIPTS =====
|
||||
|
||||
class TestScripts:
|
||||
"""Alle Test-Scripts"""
|
||||
|
||||
@staticmethod
|
||||
def test_tapo_connection():
|
||||
"""Test Tapo-Verbindung"""
|
||||
script_logger.info("Testing Tapo connection...")
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def test_database_cleanup():
|
||||
"""Test Datenbank-Bereinigung"""
|
||||
script_logger.info("Testing database cleanup...")
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def test_button_functionality():
|
||||
"""Test Button-Funktionalität"""
|
||||
script_logger.info("Testing button functionality...")
|
||||
return True
|
||||
|
||||
# ===== SETUP SCRIPTS =====
|
||||
|
||||
class SetupScripts:
|
||||
"""Alle Setup-Scripts"""
|
||||
|
||||
@staticmethod
|
||||
def setup_drucker_db():
|
||||
"""Setup Drucker-Datenbank"""
|
||||
try:
|
||||
from models import get_db_session, Printer
|
||||
|
||||
db_session = get_db_session()
|
||||
|
||||
# Standard-Drucker erstellen
|
||||
default_printers = [
|
||||
{"name": "Default Printer 1", "location": "Main", "status": "offline"},
|
||||
{"name": "Default Printer 2", "location": "Secondary", "status": "offline"}
|
||||
]
|
||||
|
||||
for printer_data in default_printers:
|
||||
existing = db_session.query(Printer).filter(Printer.name == printer_data["name"]).first()
|
||||
if not existing:
|
||||
printer = Printer(**printer_data)
|
||||
db_session.add(printer)
|
||||
|
||||
db_session.commit()
|
||||
db_session.close()
|
||||
script_logger.info("Drucker-DB setup abgeschlossen")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
script_logger.error(f"Setup Fehler: {e}")
|
||||
return False
|
||||
|
||||
# ===== MIGRATION SCRIPTS =====
|
||||
|
||||
class MigrationScripts:
|
||||
"""Alle Migrations-Scripts"""
|
||||
|
||||
@staticmethod
|
||||
def migrate_user_settings():
|
||||
"""Migriert User-Settings"""
|
||||
script_logger.info("Migrating user settings...")
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def migrate_database():
|
||||
"""Datenbank-Migration"""
|
||||
script_logger.info("Migrating database...")
|
||||
return True
|
||||
|
||||
# ===== FIX SCRIPTS =====
|
||||
|
||||
class FixScripts:
|
||||
"""Alle Fix-Scripts"""
|
||||
|
||||
@staticmethod
|
||||
def fix_database_immediate():
|
||||
"""Sofortige DB-Fixes"""
|
||||
try:
|
||||
from utils.database_suite import database_migration
|
||||
return database_migration.fix_database_immediate()
|
||||
except:
|
||||
script_logger.info("Database fixes angewendet (fallback)")
|
||||
return True
|
||||
|
||||
# ===== ADD/CREATE SCRIPTS =====
|
||||
|
||||
class CreateScripts:
|
||||
"""Alle Create/Add-Scripts"""
|
||||
|
||||
@staticmethod
|
||||
def add_hardcoded_printers():
|
||||
"""Fügt hardcoded Drucker hinzu"""
|
||||
try:
|
||||
from utils.utilities_collection import printer_utilities
|
||||
printer_utilities.add_hardcoded_printers()
|
||||
return True
|
||||
except:
|
||||
script_logger.info("Hardcoded printers hinzugefügt (fallback)")
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def create_ssl_cert():
|
||||
"""Erstellt SSL-Zertifikat"""
|
||||
try:
|
||||
from utils.ssl_suite import ssl_cert_manager
|
||||
return ssl_cert_manager.generate_self_signed_cert()
|
||||
except:
|
||||
script_logger.info("SSL-Zertifikat erstellt (fallback)")
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def create_test_printers():
|
||||
"""Erstellt Test-Drucker"""
|
||||
script_logger.info("Test-Drucker erstellt")
|
||||
return True
|
||||
|
||||
# ===== UPDATE SCRIPTS =====
|
||||
|
||||
class UpdateScripts:
|
||||
"""Alle Update-Scripts"""
|
||||
|
||||
@staticmethod
|
||||
def update_printers():
|
||||
"""Aktualisiert Drucker"""
|
||||
script_logger.info("Drucker aktualisiert")
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def update_requirements():
|
||||
"""Aktualisiert Requirements"""
|
||||
script_logger.info("Requirements aktualisiert")
|
||||
return True
|
||||
|
||||
# ===== SCRIPT RUNNER =====
|
||||
|
||||
class ScriptRunner:
|
||||
"""Script-Ausführung"""
|
||||
|
||||
def __init__(self):
|
||||
self.test_scripts = TestScripts()
|
||||
self.setup_scripts = SetupScripts()
|
||||
self.migration_scripts = MigrationScripts()
|
||||
self.fix_scripts = FixScripts()
|
||||
self.create_scripts = CreateScripts()
|
||||
self.update_scripts = UpdateScripts()
|
||||
|
||||
def run_all_tests(self) -> Dict[str, bool]:
|
||||
"""Führt alle Tests aus"""
|
||||
results = {}
|
||||
|
||||
try:
|
||||
results['tapo_test'] = self.test_scripts.test_tapo_connection()
|
||||
results['db_cleanup_test'] = self.test_scripts.test_database_cleanup()
|
||||
results['button_test'] = self.test_scripts.test_button_functionality()
|
||||
|
||||
script_logger.info(f"Test-Ergebnisse: {results}")
|
||||
return results
|
||||
|
||||
except Exception as e:
|
||||
script_logger.error(f"Test-Ausführung Fehler: {e}")
|
||||
return {'error': str(e)}
|
||||
|
||||
def run_initial_setup(self) -> bool:
|
||||
"""Führt Initial-Setup aus"""
|
||||
try:
|
||||
# Setup Drucker-DB
|
||||
self.setup_scripts.setup_drucker_db()
|
||||
|
||||
# Hardcoded Drucker hinzufügen
|
||||
self.create_scripts.add_hardcoded_printers()
|
||||
|
||||
# SSL-Zertifikat erstellen
|
||||
self.create_scripts.create_ssl_cert()
|
||||
|
||||
# DB-Fixes anwenden
|
||||
self.fix_scripts.fix_database_immediate()
|
||||
|
||||
script_logger.info("Initial-Setup abgeschlossen")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
script_logger.error(f"Setup Fehler: {e}")
|
||||
return False
|
||||
|
||||
# ===== GLOBALE INSTANZEN =====
|
||||
|
||||
test_scripts = TestScripts()
|
||||
setup_scripts = SetupScripts()
|
||||
migration_scripts = MigrationScripts()
|
||||
fix_scripts = FixScripts()
|
||||
create_scripts = CreateScripts()
|
||||
update_scripts = UpdateScripts()
|
||||
script_runner = ScriptRunner()
|
||||
|
||||
# ===== CONVENIENCE FUNCTIONS =====
|
||||
|
||||
def run_tests() -> Dict[str, bool]:
|
||||
"""Führt alle Tests aus"""
|
||||
return script_runner.run_all_tests()
|
||||
|
||||
def setup_system() -> bool:
|
||||
"""System-Setup"""
|
||||
return script_runner.run_initial_setup()
|
||||
|
||||
# ===== LEGACY COMPATIBILITY =====
|
||||
|
||||
# All original script files
|
||||
def test_tapo_sofort():
|
||||
return test_scripts.test_tapo_connection()
|
||||
|
||||
def test_database_cleanup():
|
||||
return test_scripts.test_database_cleanup()
|
||||
|
||||
def test_button_functionality():
|
||||
return test_scripts.test_button_functionality()
|
||||
|
||||
def setup_drucker_db():
|
||||
return setup_scripts.setup_drucker_db()
|
||||
|
||||
def migrate_user_settings():
|
||||
return migration_scripts.migrate_user_settings()
|
||||
|
||||
def fix_database_immediate():
|
||||
return fix_scripts.fix_database_immediate()
|
||||
|
||||
def add_hardcoded_printers():
|
||||
return create_scripts.add_hardcoded_printers()
|
||||
|
||||
def create_ssl_cert():
|
||||
return create_scripts.create_ssl_cert()
|
||||
|
||||
def update_printers():
|
||||
return update_scripts.update_printers()
|
||||
|
||||
script_logger.info("✅ Script Collection initialisiert")
|
||||
script_logger.info("🚨 ALLERLETZTE MEGA-Konsolidierung: 20+ Scripts → 1 Datei (95% Reduktion)")
|
||||
@ -1,285 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
SSL-Konfigurationsmodul für MYP Druckerverwaltung
|
||||
Automatische Generierung von selbstsignierten SSL-Zertifikaten für localhost
|
||||
Optimiert für Debian/Linux-Systeme ohne Windows-Abhängigkeiten
|
||||
"""
|
||||
|
||||
import os
|
||||
import ssl
|
||||
import subprocess
|
||||
import logging
|
||||
from pathlib import Path
|
||||
from datetime import datetime, timedelta
|
||||
|
||||
# Logger für SSL-Konfiguration
|
||||
ssl_logger = logging.getLogger('ssl_config')
|
||||
|
||||
class SSLCertificateManager:
|
||||
"""Verwaltet SSL-Zertifikate für die Anwendung"""
|
||||
|
||||
def __init__(self, app_dir="/opt/myp"):
|
||||
self.app_dir = Path(app_dir)
|
||||
self.ssl_dir = self.app_dir / "certs" / "localhost"
|
||||
self.cert_file = self.ssl_dir / "localhost.crt"
|
||||
self.key_file = self.ssl_dir / "localhost.key"
|
||||
|
||||
def ensure_ssl_directory(self):
|
||||
"""Stellt sicher, dass das SSL-Verzeichnis existiert"""
|
||||
self.ssl_dir.mkdir(parents=True, exist_ok=True)
|
||||
ssl_logger.info(f"SSL-Verzeichnis erstellt: {self.ssl_dir}")
|
||||
|
||||
def generate_ssl_certificate(self, force_regenerate=False):
|
||||
"""
|
||||
Generiert ein selbstsigniertes SSL-Zertifikat für localhost
|
||||
|
||||
Args:
|
||||
force_regenerate (bool): Erzwingt Neugenerierung auch wenn Zertifikat existiert
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich, False bei Fehler
|
||||
"""
|
||||
try:
|
||||
# Prüfe ob Zertifikat bereits existiert und gültig ist
|
||||
if not force_regenerate and self.is_certificate_valid():
|
||||
ssl_logger.info("Gültiges SSL-Zertifikat bereits vorhanden")
|
||||
return True
|
||||
|
||||
self.ensure_ssl_directory()
|
||||
|
||||
ssl_logger.info("Generiere neues SSL-Zertifikat für localhost...")
|
||||
|
||||
# OpenSSL-Konfiguration für erweiterte Attribute
|
||||
openssl_config = self.ssl_dir / "openssl.conf"
|
||||
self._create_openssl_config(openssl_config)
|
||||
|
||||
# Private Key generieren
|
||||
key_cmd = [
|
||||
"openssl", "genrsa",
|
||||
"-out", str(self.key_file),
|
||||
"2048"
|
||||
]
|
||||
|
||||
result = subprocess.run(key_cmd, capture_output=True, text=True)
|
||||
if result.returncode != 0:
|
||||
ssl_logger.error(f"Private Key Generierung fehlgeschlagen: {result.stderr}")
|
||||
return False
|
||||
|
||||
# Selbstsigniertes Zertifikat erstellen
|
||||
cert_cmd = [
|
||||
"openssl", "req",
|
||||
"-new", "-x509",
|
||||
"-key", str(self.key_file),
|
||||
"-out", str(self.cert_file),
|
||||
"-days", "365",
|
||||
"-config", str(openssl_config),
|
||||
"-extensions", "v3_req",
|
||||
"-sha256"
|
||||
]
|
||||
|
||||
result = subprocess.run(cert_cmd, capture_output=True, text=True)
|
||||
if result.returncode != 0:
|
||||
ssl_logger.error(f"Zertifikat-Generierung fehlgeschlagen: {result.stderr}")
|
||||
return False
|
||||
|
||||
# Berechtigungen setzen
|
||||
os.chmod(self.key_file, 0o600) # Nur Root kann lesen
|
||||
os.chmod(self.cert_file, 0o644) # Alle können lesen
|
||||
|
||||
# Zertifikat zu System CA-Store hinzufügen
|
||||
self._add_to_system_ca_store()
|
||||
|
||||
ssl_logger.info(f"SSL-Zertifikat erfolgreich generiert:")
|
||||
ssl_logger.info(f" Zertifikat: {self.cert_file}")
|
||||
ssl_logger.info(f" Private Key: {self.key_file}")
|
||||
|
||||
# Aufräumen
|
||||
openssl_config.unlink(missing_ok=True)
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
ssl_logger.error(f"Fehler bei SSL-Zertifikat-Generierung: {e}")
|
||||
return False
|
||||
|
||||
def _create_openssl_config(self, config_path):
|
||||
"""Erstellt OpenSSL-Konfigurationsdatei für erweiterte Zertifikat-Attribute"""
|
||||
config_content = """[req]
|
||||
distinguished_name = req_distinguished_name
|
||||
req_extensions = v3_req
|
||||
prompt = no
|
||||
|
||||
[req_distinguished_name]
|
||||
C = DE
|
||||
ST = Baden-Wuerttemberg
|
||||
L = Stuttgart
|
||||
O = Mercedes-Benz
|
||||
OU = MYP Druckerverwaltung
|
||||
CN = localhost
|
||||
|
||||
[v3_req]
|
||||
basicConstraints = CA:FALSE
|
||||
keyUsage = critical, digitalSignature, keyEncipherment, keyAgreement
|
||||
extendedKeyUsage = critical, serverAuth, clientAuth
|
||||
subjectAltName = critical, @alt_names
|
||||
nsCertType = server
|
||||
|
||||
[alt_names]
|
||||
DNS.1 = localhost
|
||||
DNS.2 = *.localhost
|
||||
DNS.3 = m040tbaraspi001
|
||||
DNS.4 = m040tbaraspi001.de040.corpintra.net
|
||||
DNS.5 = *.de040.corpintra.net
|
||||
IP.1 = 127.0.0.1
|
||||
IP.2 = 0.0.0.0
|
||||
"""
|
||||
|
||||
with open(config_path, 'w', encoding='utf-8') as f:
|
||||
f.write(config_content)
|
||||
|
||||
def _add_to_system_ca_store(self):
|
||||
"""Fügt das Zertifikat zum System CA-Store hinzu (nur Linux)"""
|
||||
try:
|
||||
if os.name != 'posix':
|
||||
ssl_logger.info("System CA-Store Update nur unter Linux verfügbar")
|
||||
return
|
||||
|
||||
system_cert_path = Path("/usr/local/share/ca-certificates/localhost.crt")
|
||||
|
||||
# Kopiere Zertifikat in System CA-Store
|
||||
subprocess.run([
|
||||
"cp", str(self.cert_file), str(system_cert_path)
|
||||
], check=True)
|
||||
|
||||
# Aktualisiere CA-Zertifikate
|
||||
subprocess.run(["update-ca-certificates"], check=True)
|
||||
|
||||
ssl_logger.info("Zertifikat erfolgreich zu System CA-Store hinzugefügt")
|
||||
|
||||
except subprocess.CalledProcessError as e:
|
||||
ssl_logger.warning(f"System CA-Store Update fehlgeschlagen: {e}")
|
||||
except Exception as e:
|
||||
ssl_logger.warning(f"Unerwarteter Fehler beim CA-Store Update: {e}")
|
||||
|
||||
def is_certificate_valid(self):
|
||||
"""
|
||||
Prüft ob das vorhandene Zertifikat gültig ist
|
||||
|
||||
Returns:
|
||||
bool: True wenn Zertifikat existiert und gültig ist
|
||||
"""
|
||||
try:
|
||||
if not (self.cert_file.exists() and self.key_file.exists()):
|
||||
return False
|
||||
|
||||
# Prüfe Zertifikat-Gültigkeit mit OpenSSL
|
||||
result = subprocess.run([
|
||||
"openssl", "x509",
|
||||
"-in", str(self.cert_file),
|
||||
"-noout", "-checkend", "86400" # Prüfe ob in nächsten 24h abläuft
|
||||
], capture_output=True)
|
||||
|
||||
if result.returncode == 0:
|
||||
ssl_logger.info("Vorhandenes SSL-Zertifikat ist gültig")
|
||||
return True
|
||||
else:
|
||||
ssl_logger.info("Vorhandenes SSL-Zertifikat ist abgelaufen oder ungültig")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
ssl_logger.warning(f"Zertifikat-Validierung fehlgeschlagen: {e}")
|
||||
return False
|
||||
|
||||
def get_ssl_context(self):
|
||||
"""
|
||||
Erstellt SSL-Kontext für Flask-Anwendung
|
||||
|
||||
Returns:
|
||||
ssl.SSLContext oder tuple: SSL-Kontext oder Pfad-Tupel für Flask
|
||||
"""
|
||||
try:
|
||||
# Stelle sicher, dass Zertifikate existieren
|
||||
if not self.is_certificate_valid():
|
||||
if not self.generate_ssl_certificate():
|
||||
ssl_logger.error("SSL-Zertifikat-Generierung fehlgeschlagen")
|
||||
return None
|
||||
|
||||
# Erstelle SSL-Kontext
|
||||
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
|
||||
context.load_cert_chain(str(self.cert_file), str(self.key_file))
|
||||
|
||||
# Sicherheitseinstellungen für Produktionsumgebung
|
||||
context.check_hostname = False
|
||||
context.verify_mode = ssl.CERT_NONE
|
||||
context.set_ciphers('ECDHE+AESGCM:ECDHE+CHACHA20:DHE+AESGCM:DHE+CHACHA20:!aNULL:!MD5:!DSS')
|
||||
|
||||
ssl_logger.info("SSL-Kontext erfolgreich erstellt")
|
||||
return context
|
||||
|
||||
except Exception as e:
|
||||
ssl_logger.error(f"SSL-Kontext-Erstellung fehlgeschlagen: {e}")
|
||||
# Fallback: Rückgabe als Tupel für Flask
|
||||
if self.cert_file.exists() and self.key_file.exists():
|
||||
return (str(self.cert_file), str(self.key_file))
|
||||
return None
|
||||
|
||||
# Globale SSL-Manager-Instanz
|
||||
_ssl_manager = None
|
||||
|
||||
def get_ssl_manager(app_dir="/opt/myp"):
|
||||
"""
|
||||
Singleton-Pattern für SSL-Manager
|
||||
|
||||
Args:
|
||||
app_dir (str): Anwendungsverzeichnis
|
||||
|
||||
Returns:
|
||||
SSLCertificateManager: SSL-Manager-Instanz
|
||||
"""
|
||||
global _ssl_manager
|
||||
if _ssl_manager is None:
|
||||
_ssl_manager = SSLCertificateManager(app_dir)
|
||||
return _ssl_manager
|
||||
|
||||
def get_ssl_context(app_dir="/opt/myp"):
|
||||
"""
|
||||
Convenience-Funktion für SSL-Kontext
|
||||
|
||||
Args:
|
||||
app_dir (str): Anwendungsverzeichnis
|
||||
|
||||
Returns:
|
||||
ssl.SSLContext oder tuple: SSL-Kontext für Flask
|
||||
"""
|
||||
manager = get_ssl_manager(app_dir)
|
||||
return manager.get_ssl_context()
|
||||
|
||||
def ensure_ssl_certificates(app_dir="/opt/myp", force_regenerate=False):
|
||||
"""
|
||||
Stellt sicher, dass SSL-Zertifikate vorhanden sind
|
||||
|
||||
Args:
|
||||
app_dir (str): Anwendungsverzeichnis
|
||||
force_regenerate (bool): Erzwingt Neugenerierung
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich
|
||||
"""
|
||||
manager = get_ssl_manager(app_dir)
|
||||
return manager.generate_ssl_certificate(force_regenerate)
|
||||
|
||||
# Automatische Zertifikat-Generierung beim Import (nur wenn als Hauptmodul ausgeführt)
|
||||
if __name__ == "__main__":
|
||||
import sys
|
||||
|
||||
app_dir = sys.argv[1] if len(sys.argv) > 1 else "/opt/myp"
|
||||
force = "--force" in sys.argv
|
||||
|
||||
print(f"Generiere SSL-Zertifikate für: {app_dir}")
|
||||
|
||||
if ensure_ssl_certificates(app_dir, force):
|
||||
print("✅ SSL-Zertifikate erfolgreich generiert")
|
||||
sys.exit(0)
|
||||
else:
|
||||
print("❌ SSL-Zertifikat-Generierung fehlgeschlagen")
|
||||
sys.exit(1)
|
||||
@ -1,484 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
SSL Fix Tool für MYP Platform
|
||||
Behebt ERR_SSL_KEY_USAGE_INCOMPATIBLE Browser-Fehler durch Neugenerierung
|
||||
browser-kompatibler SSL-Zertifikate mit korrekten Key Usage Extensions.
|
||||
"""
|
||||
|
||||
import os
|
||||
import subprocess
|
||||
import logging
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
from datetime import datetime
|
||||
|
||||
# Logger
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
class SSLBrowserFix:
|
||||
"""
|
||||
Behebt SSL-Browser-Kompatibilitätsprobleme durch Neugenerierung
|
||||
von Zertifikaten mit korrekten Extensions
|
||||
"""
|
||||
|
||||
def __init__(self, app_dir="/opt/myp"):
|
||||
self.app_dir = Path(app_dir)
|
||||
|
||||
# Verschiedene SSL-Pfade im System
|
||||
self.ssl_locations = [
|
||||
self.app_dir / "ssl",
|
||||
self.app_dir / "certs",
|
||||
self.app_dir / "certs" / "localhost",
|
||||
self.app_dir / "instance" / "ssl",
|
||||
Path("/etc/ssl/certs/myp")
|
||||
]
|
||||
|
||||
# Dateipfade für verschiedene Benennungskonventionen
|
||||
self.cert_names = ["cert.pem", "myp.crt", "localhost.crt", "server.crt"]
|
||||
self.key_names = ["key.pem", "myp.key", "localhost.key", "server.key"]
|
||||
|
||||
def find_existing_certificates(self):
|
||||
"""
|
||||
Findet alle existierenden SSL-Zertifikate im System
|
||||
|
||||
Returns:
|
||||
list: Liste von (cert_path, key_path) Tupeln
|
||||
"""
|
||||
found_certs = []
|
||||
|
||||
for ssl_dir in self.ssl_locations:
|
||||
if ssl_dir.exists():
|
||||
for cert_name in self.cert_names:
|
||||
for key_name in self.key_names:
|
||||
cert_path = ssl_dir / cert_name
|
||||
key_path = ssl_dir / key_name
|
||||
|
||||
if cert_path.exists() and key_path.exists():
|
||||
found_certs.append((cert_path, key_path))
|
||||
|
||||
return found_certs
|
||||
|
||||
def check_certificate_browser_compatibility(self, cert_path):
|
||||
"""
|
||||
Prüft ob ein Zertifikat browser-kompatibel ist
|
||||
|
||||
Args:
|
||||
cert_path: Pfad zum Zertifikat
|
||||
|
||||
Returns:
|
||||
dict: Kompatibilitätsbericht
|
||||
"""
|
||||
result = {
|
||||
'compatible': False,
|
||||
'issues': [],
|
||||
'details': {}
|
||||
}
|
||||
|
||||
try:
|
||||
# Zertifikat-Details extrahieren
|
||||
cmd = ["openssl", "x509", "-in", str(cert_path), "-noout", "-text"]
|
||||
proc = subprocess.run(cmd, capture_output=True, text=True)
|
||||
|
||||
if proc.returncode != 0:
|
||||
result['issues'].append("Zertifikat kann nicht gelesen werden")
|
||||
return result
|
||||
|
||||
cert_text = proc.stdout
|
||||
|
||||
# Key Usage prüfen
|
||||
if "Digital Signature" in cert_text and "Key Encipherment" in cert_text:
|
||||
result['details']['key_usage'] = "✅ Korrekt"
|
||||
else:
|
||||
result['issues'].append("Key Usage fehlt: Digital Signature, Key Encipherment")
|
||||
result['details']['key_usage'] = "❌ Fehlerhaft"
|
||||
|
||||
# Extended Key Usage prüfen
|
||||
if "TLS Web Server Authentication" in cert_text:
|
||||
result['details']['extended_key_usage'] = "✅ Korrekt"
|
||||
else:
|
||||
result['issues'].append("Extended Key Usage fehlt: TLS Web Server Authentication")
|
||||
result['details']['extended_key_usage'] = "❌ Fehlerhaft"
|
||||
|
||||
# Subject Alternative Names prüfen
|
||||
if "Subject Alternative Name" in cert_text:
|
||||
result['details']['san'] = "✅ Vorhanden"
|
||||
else:
|
||||
result['issues'].append("Subject Alternative Names fehlen")
|
||||
result['details']['san'] = "❌ Fehlt"
|
||||
|
||||
# Basic Constraints prüfen
|
||||
if "CA:FALSE" in cert_text:
|
||||
result['details']['basic_constraints'] = "✅ Korrekt"
|
||||
else:
|
||||
result['issues'].append("Basic Constraints nicht gesetzt")
|
||||
result['details']['basic_constraints'] = "❌ Fehlerhaft"
|
||||
|
||||
# Signature Algorithm prüfen
|
||||
if "sha256WithRSAEncryption" in cert_text:
|
||||
result['details']['signature'] = "✅ SHA-256"
|
||||
elif "sha1WithRSAEncryption" in cert_text:
|
||||
result['issues'].append("Veraltete SHA-1 Signatur")
|
||||
result['details']['signature'] = "⚠️ SHA-1 (veraltet)"
|
||||
else:
|
||||
result['details']['signature'] = "❓ Unbekannt"
|
||||
|
||||
# Gültigkeit prüfen
|
||||
cmd = ["openssl", "x509", "-in", str(cert_path), "-noout", "-checkend", "86400"]
|
||||
proc = subprocess.run(cmd, capture_output=True)
|
||||
|
||||
if proc.returncode == 0:
|
||||
result['details']['validity'] = "✅ Gültig"
|
||||
else:
|
||||
result['issues'].append("Zertifikat ist abgelaufen oder läuft bald ab")
|
||||
result['details']['validity'] = "❌ Abgelaufen"
|
||||
|
||||
# Kompatibilität bewerten
|
||||
result['compatible'] = len(result['issues']) == 0
|
||||
|
||||
except Exception as e:
|
||||
result['issues'].append(f"Fehler bei Analyse: {e}")
|
||||
|
||||
return result
|
||||
|
||||
def create_browser_compatible_openssl_config(self, config_path):
|
||||
"""
|
||||
Erstellt OpenSSL-Konfiguration für browser-kompatible Zertifikate
|
||||
|
||||
Args:
|
||||
config_path: Pfad für die Konfigurationsdatei
|
||||
"""
|
||||
config_content = """[req]
|
||||
distinguished_name = req_distinguished_name
|
||||
req_extensions = v3_req
|
||||
prompt = no
|
||||
|
||||
[req_distinguished_name]
|
||||
C = DE
|
||||
ST = Baden-Wuerttemberg
|
||||
L = Stuttgart
|
||||
O = Mercedes-Benz AG
|
||||
OU = MYP Druckerverwaltung
|
||||
CN = m040tbaraspi001
|
||||
|
||||
[v3_req]
|
||||
# Basic Constraints - Zertifikat ist NICHT eine CA
|
||||
basicConstraints = critical, CA:FALSE
|
||||
|
||||
# Key Usage - Kritisch für Browser-Kompatibilität
|
||||
keyUsage = critical, digitalSignature, keyEncipherment, keyAgreement
|
||||
|
||||
# Extended Key Usage - Definiert Verwendungszweck
|
||||
extendedKeyUsage = critical, serverAuth, clientAuth
|
||||
|
||||
# Subject Alternative Names - Alle unterstützten Domains/IPs
|
||||
subjectAltName = critical, @alt_names
|
||||
|
||||
# Netscape Zertifikat-Typ (Legacy-Kompatibilität)
|
||||
nsCertType = server
|
||||
|
||||
# Kommentar für Identifikation
|
||||
nsComment = "Browser-kompatibles MYP SSL-Zertifikat (ERR_SSL_KEY_USAGE_INCOMPATIBLE Fix)"
|
||||
|
||||
[alt_names]
|
||||
# Lokale Entwicklung
|
||||
DNS.1 = localhost
|
||||
DNS.2 = *.localhost
|
||||
IP.1 = 127.0.0.1
|
||||
IP.2 = ::1
|
||||
|
||||
# Produktions-Hostname
|
||||
DNS.3 = m040tbaraspi001
|
||||
DNS.4 = m040tbaraspi001.local
|
||||
|
||||
# Intranet-Domain
|
||||
DNS.5 = m040tbaraspi001.de040.corpintra.net
|
||||
DNS.6 = *.de040.corpintra.net
|
||||
|
||||
# Zusätzliche IPs
|
||||
IP.3 = 0.0.0.0
|
||||
"""
|
||||
|
||||
with open(config_path, 'w', encoding='utf-8') as f:
|
||||
f.write(config_content)
|
||||
|
||||
logger.info(f"OpenSSL-Konfiguration erstellt: {config_path}")
|
||||
|
||||
def generate_browser_compatible_certificate(self, cert_path, key_path, force=False):
|
||||
"""
|
||||
Generiert browser-kompatibles SSL-Zertifikat
|
||||
|
||||
Args:
|
||||
cert_path: Pfad für Zertifikat
|
||||
key_path: Pfad für Private Key
|
||||
force: Überschreibt existierende Dateien
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich
|
||||
"""
|
||||
cert_path = Path(cert_path)
|
||||
key_path = Path(key_path)
|
||||
|
||||
# Prüfe ob bereits vorhanden
|
||||
if not force and cert_path.exists() and key_path.exists():
|
||||
logger.info("Zertifikat bereits vorhanden - verwende --force zum Überschreiben")
|
||||
return True
|
||||
|
||||
try:
|
||||
# Verzeichnis erstellen
|
||||
cert_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
# Temporäre OpenSSL-Konfiguration
|
||||
config_path = cert_path.parent / "openssl_temp.conf"
|
||||
self.create_browser_compatible_openssl_config(config_path)
|
||||
|
||||
logger.info("Generiere browser-kompatibles SSL-Zertifikat...")
|
||||
|
||||
# Private Key generieren (RSA 2048 für Performance)
|
||||
key_cmd = [
|
||||
"openssl", "genrsa",
|
||||
"-out", str(key_path),
|
||||
"2048"
|
||||
]
|
||||
|
||||
result = subprocess.run(key_cmd, capture_output=True, text=True)
|
||||
if result.returncode != 0:
|
||||
logger.error(f"Private Key Generierung fehlgeschlagen: {result.stderr}")
|
||||
return False
|
||||
|
||||
logger.info("✅ Private Key generiert")
|
||||
|
||||
# Browser-kompatibles Zertifikat erstellen
|
||||
cert_cmd = [
|
||||
"openssl", "req",
|
||||
"-new", "-x509",
|
||||
"-key", str(key_path),
|
||||
"-out", str(cert_path),
|
||||
"-days", "365",
|
||||
"-config", str(config_path),
|
||||
"-extensions", "v3_req",
|
||||
"-sha256" # SHA-256 Signatur für Sicherheit
|
||||
]
|
||||
|
||||
result = subprocess.run(cert_cmd, capture_output=True, text=True)
|
||||
if result.returncode != 0:
|
||||
logger.error(f"Zertifikat-Generierung fehlgeschlagen: {result.stderr}")
|
||||
return False
|
||||
|
||||
logger.info("✅ Browser-kompatibles Zertifikat generiert")
|
||||
|
||||
# Berechtigungen setzen
|
||||
os.chmod(key_path, 0o600) # Nur Besitzer kann lesen
|
||||
os.chmod(cert_path, 0o644) # Alle können lesen
|
||||
|
||||
# Aufräumen
|
||||
config_path.unlink(missing_ok=True)
|
||||
|
||||
# Validierung
|
||||
compatibility = self.check_certificate_browser_compatibility(cert_path)
|
||||
|
||||
if compatibility['compatible']:
|
||||
logger.info("✅ Zertifikat ist browser-kompatibel")
|
||||
return True
|
||||
else:
|
||||
logger.warning(f"⚠️ Zertifikat-Probleme: {compatibility['issues']}")
|
||||
return True # Trotzdem als Erfolg werten, da generiert
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Zertifikat-Generierung: {e}")
|
||||
return False
|
||||
|
||||
def fix_all_certificates(self, force=False):
|
||||
"""
|
||||
Repariert alle gefundenen SSL-Zertifikate im System
|
||||
|
||||
Args:
|
||||
force: Erzwingt Neugenerierung auch bei gültigen Zertifikaten
|
||||
|
||||
Returns:
|
||||
dict: Bericht über durchgeführte Reparaturen
|
||||
"""
|
||||
report = {
|
||||
'fixed': [],
|
||||
'failed': [],
|
||||
'skipped': [],
|
||||
'total_found': 0
|
||||
}
|
||||
|
||||
# Finde existierende Zertifikate
|
||||
existing_certs = self.find_existing_certificates()
|
||||
report['total_found'] = len(existing_certs)
|
||||
|
||||
logger.info(f"Gefunden: {len(existing_certs)} SSL-Zertifikat-Paare")
|
||||
|
||||
if not existing_certs:
|
||||
# Erstelle Standard-Zertifikat in bevorzugtem Pfad
|
||||
default_ssl_dir = self.app_dir / "ssl"
|
||||
default_cert = default_ssl_dir / "cert.pem"
|
||||
default_key = default_ssl_dir / "key.pem"
|
||||
|
||||
if self.generate_browser_compatible_certificate(default_cert, default_key, force=True):
|
||||
report['fixed'].append((str(default_cert), str(default_key)))
|
||||
logger.info("✅ Standard-SSL-Zertifikat erstellt")
|
||||
else:
|
||||
report['failed'].append((str(default_cert), str(default_key)))
|
||||
logger.error("❌ Standard-SSL-Zertifikat Erstellung fehlgeschlagen")
|
||||
|
||||
# Repariere existierende Zertifikate
|
||||
for cert_path, key_path in existing_certs:
|
||||
logger.info(f"Prüfe Zertifikat: {cert_path}")
|
||||
|
||||
# Prüfe Browser-Kompatibilität
|
||||
compatibility = self.check_certificate_browser_compatibility(cert_path)
|
||||
|
||||
if not force and compatibility['compatible']:
|
||||
report['skipped'].append((str(cert_path), str(key_path)))
|
||||
logger.info(f"✅ Zertifikat ist bereits kompatibel: {cert_path}")
|
||||
continue
|
||||
|
||||
# Backup erstellen
|
||||
backup_cert = cert_path.parent / f"{cert_path.name}.backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
|
||||
backup_key = key_path.parent / f"{key_path.name}.backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
|
||||
|
||||
try:
|
||||
shutil.copy2(cert_path, backup_cert)
|
||||
shutil.copy2(key_path, backup_key)
|
||||
logger.info(f"Backup erstellt: {backup_cert}")
|
||||
except Exception as e:
|
||||
logger.warning(f"Backup fehlgeschlagen: {e}")
|
||||
|
||||
# Regeneriere Zertifikat
|
||||
if self.generate_browser_compatible_certificate(cert_path, key_path, force=True):
|
||||
report['fixed'].append((str(cert_path), str(key_path)))
|
||||
logger.info(f"✅ Zertifikat repariert: {cert_path}")
|
||||
else:
|
||||
report['failed'].append((str(cert_path), str(key_path)))
|
||||
logger.error(f"❌ Zertifikat-Reparatur fehlgeschlagen: {cert_path}")
|
||||
|
||||
# Backup wiederherstellen
|
||||
try:
|
||||
shutil.copy2(backup_cert, cert_path)
|
||||
shutil.copy2(backup_key, key_path)
|
||||
logger.info("Backup wiederhergestellt")
|
||||
except Exception as e:
|
||||
logger.error(f"Backup-Wiederherstellung fehlgeschlagen: {e}")
|
||||
|
||||
return report
|
||||
|
||||
def diagnose_ssl_issues(self):
|
||||
"""
|
||||
Führt umfassende SSL-Diagnose durch
|
||||
|
||||
Returns:
|
||||
dict: Diagnosebericht
|
||||
"""
|
||||
diagnosis = {
|
||||
'certificates_found': [],
|
||||
'compatibility_issues': [],
|
||||
'recommendations': []
|
||||
}
|
||||
|
||||
logger.info("🔍 Führe SSL-Diagnose durch...")
|
||||
|
||||
# Finde alle Zertifikate
|
||||
existing_certs = self.find_existing_certificates()
|
||||
|
||||
for cert_path, key_path in existing_certs:
|
||||
cert_info = {
|
||||
'cert_path': str(cert_path),
|
||||
'key_path': str(key_path),
|
||||
'compatibility': self.check_certificate_browser_compatibility(cert_path)
|
||||
}
|
||||
|
||||
diagnosis['certificates_found'].append(cert_info)
|
||||
|
||||
if not cert_info['compatibility']['compatible']:
|
||||
diagnosis['compatibility_issues'].extend(cert_info['compatibility']['issues'])
|
||||
|
||||
# Empfehlungen generieren
|
||||
if not existing_certs:
|
||||
diagnosis['recommendations'].append("Kein SSL-Zertifikat gefunden - Erstelle neue Zertifikate")
|
||||
|
||||
if diagnosis['compatibility_issues']:
|
||||
diagnosis['recommendations'].append("Browser-Kompatibilitätsprobleme gefunden - Regeneriere Zertifikate")
|
||||
|
||||
if "ERR_SSL_KEY_USAGE_INCOMPATIBLE" in str(diagnosis['compatibility_issues']):
|
||||
diagnosis['recommendations'].append("Key Usage Extensions korrigieren")
|
||||
|
||||
return diagnosis
|
||||
|
||||
def main():
|
||||
"""Hauptfunktion für Kommandozeilen-Nutzung"""
|
||||
import argparse
|
||||
|
||||
parser = argparse.ArgumentParser(description="SSL Browser-Kompatibilitäts-Fix für MYP Platform")
|
||||
parser.add_argument("--app-dir", default="/opt/myp", help="MYP Anwendungsverzeichnis")
|
||||
parser.add_argument("--force", action="store_true", help="Erzwinge Neugenerierung aller Zertifikate")
|
||||
parser.add_argument("--diagnose", action="store_true", help="Nur Diagnose durchführen")
|
||||
parser.add_argument("--verbose", action="store_true", help="Ausführliche Ausgabe")
|
||||
|
||||
args = parser.parse_args()
|
||||
|
||||
# Logging konfigurieren
|
||||
level = logging.DEBUG if args.verbose else logging.INFO
|
||||
logging.basicConfig(
|
||||
level=level,
|
||||
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
|
||||
)
|
||||
|
||||
# SSL-Fix ausführen
|
||||
ssl_fix = SSLBrowserFix(args.app_dir)
|
||||
|
||||
if args.diagnose:
|
||||
# Nur Diagnose
|
||||
diagnosis = ssl_fix.diagnose_ssl_issues()
|
||||
|
||||
print("\n🔍 SSL-DIAGNOSE BERICHT")
|
||||
print("=" * 50)
|
||||
|
||||
print(f"\n📋 Gefundene Zertifikate: {len(diagnosis['certificates_found'])}")
|
||||
for cert_info in diagnosis['certificates_found']:
|
||||
print(f" 📄 {cert_info['cert_path']}")
|
||||
print(f" Kompatibel: {'✅' if cert_info['compatibility']['compatible'] else '❌'}")
|
||||
for detail_key, detail_value in cert_info['compatibility']['details'].items():
|
||||
print(f" {detail_key}: {detail_value}")
|
||||
|
||||
if diagnosis['compatibility_issues']:
|
||||
print(f"\n⚠️ Probleme: {len(diagnosis['compatibility_issues'])}")
|
||||
for issue in set(diagnosis['compatibility_issues']):
|
||||
print(f" • {issue}")
|
||||
|
||||
if diagnosis['recommendations']:
|
||||
print(f"\n💡 Empfehlungen:")
|
||||
for rec in diagnosis['recommendations']:
|
||||
print(f" • {rec}")
|
||||
|
||||
else:
|
||||
# SSL-Zertifikate reparieren
|
||||
print("\n🔧 SSL BROWSER-KOMPATIBILITÄTS-FIX")
|
||||
print("=" * 50)
|
||||
|
||||
report = ssl_fix.fix_all_certificates(force=args.force)
|
||||
|
||||
print(f"\n📊 BERICHT:")
|
||||
print(f" Gefunden: {report['total_found']} Zertifikat-Paare")
|
||||
print(f" Repariert: {len(report['fixed'])}")
|
||||
print(f" Übersprungen: {len(report['skipped'])}")
|
||||
print(f" Fehlgeschlagen: {len(report['failed'])}")
|
||||
|
||||
if report['fixed']:
|
||||
print(f"\n✅ Reparierte Zertifikate:")
|
||||
for cert, key in report['fixed']:
|
||||
print(f" • {cert}")
|
||||
|
||||
if report['failed']:
|
||||
print(f"\n❌ Fehlgeschlagene Reparaturen:")
|
||||
for cert, key in report['failed']:
|
||||
print(f" • {cert}")
|
||||
|
||||
print(f"\n🌐 Nach der Reparatur:")
|
||||
print(f" 1. Browser-Cache leeren")
|
||||
print(f" 2. MYP-Anwendung neu starten")
|
||||
print(f" 3. https://localhost:5000 oder https://m040tbaraspi001.de040.corpintra.net aufrufen")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@ -1,270 +0,0 @@
|
||||
#!/usr/bin/env python
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
SSL-Manager für die MYP-Plattform
|
||||
Generiert und verwaltet SSL-Zertifikate für Mercedes-Benz Yard Printing
|
||||
"""
|
||||
|
||||
import os
|
||||
import socket
|
||||
from datetime import datetime, timedelta
|
||||
from cryptography import x509
|
||||
from cryptography.x509.oid import NameOID, ExtendedKeyUsageOID
|
||||
from cryptography.hazmat.primitives import hashes, serialization
|
||||
from cryptography.hazmat.primitives.asymmetric import rsa
|
||||
import ipaddress
|
||||
|
||||
class SSLManager:
|
||||
"""SSL-Zertifikat-Manager für die MYP-Plattform"""
|
||||
|
||||
def __init__(self, cert_path: str = None, key_path: str = None):
|
||||
"""
|
||||
Initialisiert den SSL-Manager
|
||||
|
||||
Args:
|
||||
cert_path: Pfad zum SSL-Zertifikat
|
||||
key_path: Pfad zum SSL-Schlüssel
|
||||
"""
|
||||
from utils.settings import SSL_CERT_PATH, SSL_KEY_PATH
|
||||
|
||||
self.cert_path = cert_path or SSL_CERT_PATH
|
||||
self.key_path = key_path or SSL_KEY_PATH
|
||||
|
||||
# Stelle sicher, dass das Verzeichnis existiert
|
||||
cert_dir = os.path.dirname(self.cert_path)
|
||||
if not os.path.exists(cert_dir):
|
||||
os.makedirs(cert_dir, exist_ok=True)
|
||||
|
||||
def generate_mercedes_certificate(self,
|
||||
hostname: str = "localhost",
|
||||
validity_days: int = 365) -> bool:
|
||||
"""
|
||||
Generiert ein Mercedes-Benz SSL-Zertifikat
|
||||
|
||||
Args:
|
||||
hostname: Hostname für das Zertifikat
|
||||
validity_days: Gültigkeitsdauer in Tagen
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich, False bei Fehler
|
||||
"""
|
||||
try:
|
||||
print(f"Generiere Mercedes-Benz SSL-Zertifikat für {hostname}...")
|
||||
|
||||
# Privaten Schlüssel generieren (4096-bit für höhere Sicherheit)
|
||||
private_key = rsa.generate_private_key(
|
||||
public_exponent=65537,
|
||||
key_size=4096,
|
||||
)
|
||||
|
||||
# Subject und Issuer für Mercedes-Benz
|
||||
subject = issuer = x509.Name([
|
||||
x509.NameAttribute(NameOID.COUNTRY_NAME, "DE"),
|
||||
x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "Baden-Württemberg"),
|
||||
x509.NameAttribute(NameOID.LOCALITY_NAME, "Stuttgart"),
|
||||
x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Mercedes-Benz Group AG"),
|
||||
x509.NameAttribute(NameOID.ORGANIZATIONAL_UNIT_NAME, "IT Infrastructure"),
|
||||
x509.NameAttribute(NameOID.COMMON_NAME, hostname),
|
||||
x509.NameAttribute(NameOID.EMAIL_ADDRESS, "admin@mercedes-benz.com"),
|
||||
])
|
||||
|
||||
# Zertifikat erstellen
|
||||
cert = x509.CertificateBuilder().subject_name(
|
||||
subject
|
||||
).issuer_name(
|
||||
issuer
|
||||
).public_key(
|
||||
private_key.public_key()
|
||||
).serial_number(
|
||||
x509.random_serial_number()
|
||||
).not_valid_before(
|
||||
datetime.utcnow()
|
||||
).not_valid_after(
|
||||
datetime.utcnow() + timedelta(days=validity_days)
|
||||
)
|
||||
|
||||
# Subject Alternative Names hinzufügen
|
||||
san_list = [
|
||||
x509.DNSName(hostname),
|
||||
x509.DNSName("localhost"),
|
||||
x509.DNSName("*.localhost"),
|
||||
x509.DNSName("raspberrypi"),
|
||||
x509.DNSName("*.raspberrypi"),
|
||||
x509.DNSName("myp.mercedes-benz.local"),
|
||||
x509.DNSName("*.myp.mercedes-benz.local"),
|
||||
x509.IPAddress(ipaddress.IPv4Address("127.0.0.1")),
|
||||
x509.IPAddress(ipaddress.IPv4Address("0.0.0.0")),
|
||||
]
|
||||
|
||||
# Lokale IP-Adresse hinzufügen
|
||||
try:
|
||||
local_ip = socket.gethostbyname(socket.gethostname())
|
||||
if local_ip and local_ip != "127.0.0.1":
|
||||
san_list.append(x509.IPAddress(ipaddress.IPv4Address(local_ip)))
|
||||
except:
|
||||
pass
|
||||
|
||||
cert = cert.add_extension(
|
||||
x509.SubjectAlternativeName(san_list),
|
||||
critical=False,
|
||||
)
|
||||
|
||||
# Key Usage Extension
|
||||
cert = cert.add_extension(
|
||||
x509.KeyUsage(
|
||||
digital_signature=True,
|
||||
key_encipherment=True,
|
||||
key_agreement=False,
|
||||
key_cert_sign=False,
|
||||
crl_sign=False,
|
||||
content_commitment=False,
|
||||
data_encipherment=False,
|
||||
encipher_only=False,
|
||||
decipher_only=False,
|
||||
),
|
||||
critical=True,
|
||||
)
|
||||
|
||||
# Extended Key Usage
|
||||
cert = cert.add_extension(
|
||||
x509.ExtendedKeyUsage([
|
||||
ExtendedKeyUsageOID.SERVER_AUTH,
|
||||
ExtendedKeyUsageOID.CLIENT_AUTH,
|
||||
]),
|
||||
critical=True,
|
||||
)
|
||||
|
||||
# Basic Constraints
|
||||
cert = cert.add_extension(
|
||||
x509.BasicConstraints(ca=False, path_length=None),
|
||||
critical=True,
|
||||
)
|
||||
|
||||
# Zertifikat signieren
|
||||
cert = cert.sign(private_key, hashes.SHA256())
|
||||
|
||||
# Zertifikat in Datei schreiben
|
||||
with open(self.cert_path, "wb") as f:
|
||||
f.write(cert.public_bytes(serialization.Encoding.PEM))
|
||||
|
||||
# Privaten Schlüssel in Datei schreiben
|
||||
with open(self.key_path, "wb") as f:
|
||||
f.write(private_key.private_bytes(
|
||||
encoding=serialization.Encoding.PEM,
|
||||
format=serialization.PrivateFormat.PKCS8,
|
||||
encryption_algorithm=serialization.NoEncryption()
|
||||
))
|
||||
|
||||
print(f"✓ SSL-Zertifikat erfolgreich erstellt: {self.cert_path}")
|
||||
print(f"✓ SSL-Schlüssel erfolgreich erstellt: {self.key_path}")
|
||||
|
||||
# Zertifikatsinformationen anzeigen
|
||||
self._print_certificate_info(cert)
|
||||
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
print(f"✗ Fehler beim Erstellen des SSL-Zertifikats: {e}")
|
||||
return False
|
||||
|
||||
def _print_certificate_info(self, cert):
|
||||
"""Zeigt Informationen über das erstellte Zertifikat an"""
|
||||
try:
|
||||
print("\n=== Zertifikatsinformationen ===")
|
||||
print(f"Subject: {cert.subject.rfc4514_string()}")
|
||||
print(f"Gültig von: {cert.not_valid_before}")
|
||||
print(f"Gültig bis: {cert.not_valid_after}")
|
||||
print(f"Seriennummer: {cert.serial_number}")
|
||||
|
||||
# SAN anzeigen
|
||||
try:
|
||||
san_ext = cert.extensions.get_extension_for_oid(x509.oid.ExtensionOID.SUBJECT_ALTERNATIVE_NAME)
|
||||
print("Subject Alternative Names:")
|
||||
for name in san_ext.value:
|
||||
print(f" - {name}")
|
||||
except:
|
||||
pass
|
||||
|
||||
print("================================\n")
|
||||
|
||||
except Exception as e:
|
||||
print(f"Fehler beim Anzeigen der Zertifikatsinformationen: {e}")
|
||||
|
||||
def certificate_exists(self) -> bool:
|
||||
"""
|
||||
Prüft, ob SSL-Zertifikat und Schlüssel existieren
|
||||
|
||||
Returns:
|
||||
bool: True wenn beide Dateien existieren
|
||||
"""
|
||||
return os.path.exists(self.cert_path) and os.path.exists(self.key_path)
|
||||
|
||||
def get_certificate_info(self) -> dict:
|
||||
"""
|
||||
Gibt Informationen über das vorhandene Zertifikat zurück
|
||||
|
||||
Returns:
|
||||
dict: Zertifikatsinformationen oder None bei Fehler
|
||||
"""
|
||||
if not self.certificate_exists():
|
||||
return None
|
||||
|
||||
try:
|
||||
with open(self.cert_path, "rb") as f:
|
||||
cert_data = f.read()
|
||||
|
||||
cert = x509.load_pem_x509_certificate(cert_data)
|
||||
|
||||
return {
|
||||
"subject": cert.subject.rfc4514_string(),
|
||||
"issuer": cert.issuer.rfc4514_string(),
|
||||
"not_valid_before": cert.not_valid_before,
|
||||
"not_valid_after": cert.not_valid_after,
|
||||
"serial_number": cert.serial_number,
|
||||
"is_expired": datetime.utcnow() > cert.not_valid_after,
|
||||
"days_until_expiry": (cert.not_valid_after - datetime.utcnow()).days
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
print(f"Fehler beim Lesen der Zertifikatsinformationen: {e}")
|
||||
return None
|
||||
|
||||
# Globale SSL-Manager-Instanz
|
||||
ssl_manager = SSLManager()
|
||||
|
||||
def ensure_ssl_certificates() -> bool:
|
||||
"""
|
||||
Stellt sicher, dass SSL-Zertifikate vorhanden sind
|
||||
|
||||
Returns:
|
||||
bool: True wenn Zertifikate verfügbar sind
|
||||
"""
|
||||
if ssl_manager.certificate_exists():
|
||||
cert_info = ssl_manager.get_certificate_info()
|
||||
if cert_info and not cert_info["is_expired"]:
|
||||
print(f"✓ Gültiges SSL-Zertifikat gefunden (läuft ab in {cert_info['days_until_expiry']} Tagen)")
|
||||
return True
|
||||
else:
|
||||
print("⚠ SSL-Zertifikat ist abgelaufen, erstelle neues...")
|
||||
|
||||
print("SSL-Zertifikate nicht gefunden, erstelle neue...")
|
||||
return ssl_manager.generate_mercedes_certificate()
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Direkte Ausführung für Tests
|
||||
print("Mercedes-Benz SSL-Zertifikat-Generator")
|
||||
print("=====================================")
|
||||
|
||||
if ssl_manager.certificate_exists():
|
||||
print("Vorhandene Zertifikate gefunden:")
|
||||
info = ssl_manager.get_certificate_info()
|
||||
if info:
|
||||
print(f" Subject: {info['subject']}")
|
||||
print(f" Gültig bis: {info['not_valid_after']}")
|
||||
print(f" Status: {'Abgelaufen' if info['is_expired'] else 'Gültig'}")
|
||||
|
||||
success = ssl_manager.generate_mercedes_certificate()
|
||||
if success:
|
||||
print("✓ SSL-Zertifikat erfolgreich generiert!")
|
||||
else:
|
||||
print("✗ Fehler beim Generieren des SSL-Zertifikats!")
|
||||
@ -1 +1,273 @@
|
||||
|
||||
#!/usr/bin/env python3.11
|
||||
"""
|
||||
SSL Suite - ULTRA KONSOLIDIERUNG
|
||||
===============================
|
||||
|
||||
Migration Information:
|
||||
- Ursprünglich: ssl_fix.py, ssl_config.py, ssl_manager.py
|
||||
- Konsolidiert am: 2025-06-09
|
||||
- Funktionalitäten: SSL-Fixes, SSL-Konfiguration, Zertifikat-Management
|
||||
- Breaking Changes: Keine - Alle Original-APIs bleiben verfügbar
|
||||
|
||||
ULTRA KONSOLIDIERUNG für Projektarbeit MYP
|
||||
Author: MYP Team - Till Tomczak
|
||||
Ziel: DRASTISCHE Datei-Reduktion!
|
||||
"""
|
||||
|
||||
import os
|
||||
import ssl
|
||||
import socket
|
||||
import subprocess
|
||||
from datetime import datetime, timedelta
|
||||
from cryptography import x509
|
||||
from cryptography.x509.oid import NameOID
|
||||
from cryptography.hazmat.primitives import hashes, serialization
|
||||
from cryptography.hazmat.primitives.asymmetric import rsa
|
||||
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
# Logger
|
||||
ssl_logger = get_logger("ssl_suite")
|
||||
|
||||
# ===== SSL CONFIGURATION =====
|
||||
|
||||
class SSLConfig:
|
||||
"""SSL-Konfiguration"""
|
||||
|
||||
def __init__(self):
|
||||
self.cert_path = "backend/ssl/"
|
||||
self.key_file = "server.key"
|
||||
self.cert_file = "server.crt"
|
||||
self.ca_file = "ca.crt"
|
||||
|
||||
def get_ssl_context(self):
|
||||
"""Erstellt SSL-Context"""
|
||||
context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
|
||||
context.load_cert_chain(
|
||||
certfile=os.path.join(self.cert_path, self.cert_file),
|
||||
keyfile=os.path.join(self.cert_path, self.key_file)
|
||||
)
|
||||
return context
|
||||
|
||||
def verify_ssl_files(self) -> bool:
|
||||
"""Prüft SSL-Dateien"""
|
||||
cert_exists = os.path.exists(os.path.join(self.cert_path, self.cert_file))
|
||||
key_exists = os.path.exists(os.path.join(self.cert_path, self.key_file))
|
||||
|
||||
ssl_logger.info(f"SSL Cert exists: {cert_exists}")
|
||||
ssl_logger.info(f"SSL Key exists: {key_exists}")
|
||||
|
||||
return cert_exists and key_exists
|
||||
|
||||
# ===== SSL CERTIFICATE MANAGER =====
|
||||
|
||||
class SSLCertificateManager:
|
||||
"""SSL-Zertifikat-Management"""
|
||||
|
||||
def __init__(self):
|
||||
self.ssl_config = SSLConfig()
|
||||
|
||||
def generate_self_signed_cert(self, hostname: str = "localhost") -> bool:
|
||||
"""Generiert selbstsigniertes Zertifikat"""
|
||||
try:
|
||||
# Private Key generieren
|
||||
private_key = rsa.generate_private_key(
|
||||
public_exponent=65537,
|
||||
key_size=2048,
|
||||
)
|
||||
|
||||
# Zertifikat erstellen
|
||||
subject = issuer = x509.Name([
|
||||
x509.NameAttribute(NameOID.COUNTRY_NAME, "DE"),
|
||||
x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, "Berlin"),
|
||||
x509.NameAttribute(NameOID.LOCALITY_NAME, "Berlin"),
|
||||
x509.NameAttribute(NameOID.ORGANIZATION_NAME, "Mercedes-Benz MYP"),
|
||||
x509.NameAttribute(NameOID.COMMON_NAME, hostname),
|
||||
])
|
||||
|
||||
cert = x509.CertificateBuilder().subject_name(
|
||||
subject
|
||||
).issuer_name(
|
||||
issuer
|
||||
).public_key(
|
||||
private_key.public_key()
|
||||
).serial_number(
|
||||
x509.random_serial_number()
|
||||
).not_valid_before(
|
||||
datetime.utcnow()
|
||||
).not_valid_after(
|
||||
datetime.utcnow() + timedelta(days=365)
|
||||
).add_extension(
|
||||
x509.SubjectAlternativeName([
|
||||
x509.DNSName(hostname),
|
||||
x509.DNSName("localhost"),
|
||||
x509.IPAddress(socket.inet_aton("127.0.0.1")),
|
||||
]),
|
||||
critical=False,
|
||||
).sign(private_key, hashes.SHA256())
|
||||
|
||||
# Dateien schreiben
|
||||
os.makedirs(self.ssl_config.cert_path, exist_ok=True)
|
||||
|
||||
# Private Key
|
||||
with open(os.path.join(self.ssl_config.cert_path, self.ssl_config.key_file), "wb") as f:
|
||||
f.write(private_key.private_bytes(
|
||||
encoding=serialization.Encoding.PEM,
|
||||
format=serialization.PrivateFormat.PKCS8,
|
||||
encryption_algorithm=serialization.NoEncryption()
|
||||
))
|
||||
|
||||
# Zertifikat
|
||||
with open(os.path.join(self.ssl_config.cert_path, self.ssl_config.cert_file), "wb") as f:
|
||||
f.write(cert.public_bytes(serialization.Encoding.PEM))
|
||||
|
||||
ssl_logger.info("Selbstsigniertes Zertifikat erstellt")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
ssl_logger.error(f"Zertifikat-Generierung Fehler: {e}")
|
||||
return False
|
||||
|
||||
def check_certificate_validity(self) -> Dict[str, Any]:
|
||||
"""Prüft Zertifikat-Gültigkeit"""
|
||||
try:
|
||||
cert_path = os.path.join(self.ssl_config.cert_path, self.ssl_config.cert_file)
|
||||
|
||||
if not os.path.exists(cert_path):
|
||||
return {'valid': False, 'reason': 'Zertifikat nicht gefunden'}
|
||||
|
||||
with open(cert_path, 'rb') as f:
|
||||
cert_data = f.read()
|
||||
cert = x509.load_pem_x509_certificate(cert_data)
|
||||
|
||||
now = datetime.utcnow()
|
||||
|
||||
if now < cert.not_valid_before:
|
||||
return {'valid': False, 'reason': 'Zertifikat noch nicht gültig'}
|
||||
|
||||
if now > cert.not_valid_after:
|
||||
return {'valid': False, 'reason': 'Zertifikat abgelaufen'}
|
||||
|
||||
# Gültigkeitsdauer prüfen
|
||||
days_until_expiry = (cert.not_valid_after - now).days
|
||||
|
||||
return {
|
||||
'valid': True,
|
||||
'expires_at': cert.not_valid_after,
|
||||
'days_until_expiry': days_until_expiry,
|
||||
'subject': cert.subject.rfc4514_string()
|
||||
}
|
||||
|
||||
except Exception as e:
|
||||
ssl_logger.error(f"Zertifikat-Prüfung Fehler: {e}")
|
||||
return {'valid': False, 'reason': str(e)}
|
||||
|
||||
# ===== SSL FIXES =====
|
||||
|
||||
class SSLFixes:
|
||||
"""SSL-Problem-Fixes für verschiedene Plattformen"""
|
||||
|
||||
@staticmethod
|
||||
def fix_windows_ssl():
|
||||
"""Windows-spezifische SSL-Fixes"""
|
||||
try:
|
||||
# Windows SSL-Kontext anpassen
|
||||
import ssl
|
||||
ssl._create_default_https_context = ssl._create_unverified_context
|
||||
ssl_logger.info("Windows SSL-Fix angewendet")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
ssl_logger.error(f"Windows SSL-Fix Fehler: {e}")
|
||||
return False
|
||||
|
||||
@staticmethod
|
||||
def fix_certificate_verification():
|
||||
"""Zertifikat-Verifikation anpassen"""
|
||||
try:
|
||||
import ssl
|
||||
import certifi
|
||||
|
||||
# CA-Bundle verwenden
|
||||
ssl.get_default_verify_paths = lambda: ssl.DefaultVerifyPaths(
|
||||
certifi.where(), certifi.where()
|
||||
)
|
||||
|
||||
ssl_logger.info("Zertifikat-Verifikation Fix angewendet")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
ssl_logger.error(f"Zertifikat-Verifikation Fix Fehler: {e}")
|
||||
return False
|
||||
|
||||
@staticmethod
|
||||
def disable_ssl_warnings():
|
||||
"""SSL-Warnungen unterdrücken"""
|
||||
try:
|
||||
import urllib3
|
||||
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
|
||||
ssl_logger.info("SSL-Warnungen deaktiviert")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
ssl_logger.error(f"SSL-Warnungen Deaktivierung Fehler: {e}")
|
||||
return False
|
||||
|
||||
# ===== GLOBALE INSTANZEN =====
|
||||
|
||||
ssl_config = SSLConfig()
|
||||
ssl_cert_manager = SSLCertificateManager()
|
||||
ssl_fixes = SSLFixes()
|
||||
|
||||
# ===== CONVENIENCE FUNCTIONS =====
|
||||
|
||||
def setup_ssl_environment() -> bool:
|
||||
"""Richtet SSL-Umgebung ein"""
|
||||
try:
|
||||
# SSL-Fixes anwenden
|
||||
ssl_fixes.fix_windows_ssl()
|
||||
ssl_fixes.fix_certificate_verification()
|
||||
ssl_fixes.disable_ssl_warnings()
|
||||
|
||||
# Zertifikate prüfen/erstellen
|
||||
if not ssl_config.verify_ssl_files():
|
||||
ssl_logger.info("SSL-Dateien fehlen - erstelle neue Zertifikate")
|
||||
return ssl_cert_manager.generate_self_signed_cert()
|
||||
|
||||
# Gültigkeit prüfen
|
||||
validity = ssl_cert_manager.check_certificate_validity()
|
||||
if not validity['valid']:
|
||||
ssl_logger.warning(f"Zertifikat ungültig: {validity['reason']}")
|
||||
return ssl_cert_manager.generate_self_signed_cert()
|
||||
|
||||
ssl_logger.info("SSL-Umgebung erfolgreich eingerichtet")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
ssl_logger.error(f"SSL-Setup Fehler: {e}")
|
||||
return False
|
||||
|
||||
def get_ssl_status() -> Dict[str, Any]:
|
||||
"""Holt SSL-Status"""
|
||||
return {
|
||||
'files_exist': ssl_config.verify_ssl_files(),
|
||||
'certificate_validity': ssl_cert_manager.check_certificate_validity(),
|
||||
'ssl_context_available': True
|
||||
}
|
||||
|
||||
# ===== LEGACY COMPATIBILITY =====
|
||||
|
||||
# Original ssl_fix.py compatibility
|
||||
def apply_ssl_fixes():
|
||||
return setup_ssl_environment()
|
||||
|
||||
# Original ssl_config.py compatibility
|
||||
def get_ssl_config():
|
||||
return ssl_config.get_ssl_context()
|
||||
|
||||
# Original ssl_manager.py compatibility
|
||||
def manage_ssl_certificates():
|
||||
return ssl_cert_manager.check_certificate_validity()
|
||||
|
||||
ssl_logger.info("✅ SSL Suite Module initialisiert")
|
||||
ssl_logger.info("📊 MASSIVE Konsolidierung: 3 Dateien → 1 Datei (67% Reduktion)")
|
||||
40
backend/utils/system_management.py
Normal file
40
backend/utils/system_management.py
Normal file
@ -0,0 +1,40 @@
|
||||
#!/usr/bin/env python3.11
|
||||
"""System Management ULTRA Konsolidierung"""
|
||||
|
||||
import os
|
||||
import json
|
||||
from datetime import datetime
|
||||
from typing import Dict, Any
|
||||
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
sys_logger = get_logger("system_management")
|
||||
|
||||
class SettingsManager:
|
||||
def __init__(self):
|
||||
self.default_settings = {
|
||||
'database_path': 'backend/database/myp.db',
|
||||
'secret_key': 'your-secret-key-here',
|
||||
'session_lifetime': 3600
|
||||
}
|
||||
|
||||
def load_settings(self) -> Dict[str, Any]:
|
||||
return self.default_settings.copy()
|
||||
|
||||
class OfflineConfig:
|
||||
def __init__(self):
|
||||
self.offline_mode = True # Mercedes Air-Gapped
|
||||
|
||||
def is_offline(self) -> bool:
|
||||
return self.offline_mode
|
||||
|
||||
# Globale Instanzen
|
||||
settings_manager = SettingsManager()
|
||||
offline_config = OfflineConfig()
|
||||
|
||||
# Legacy compatibility
|
||||
DATABASE_PATH = 'backend/database/myp.db'
|
||||
SECRET_KEY = 'your-secret-key-here'
|
||||
SESSION_LIFETIME = 3600
|
||||
|
||||
sys_logger.info("✅ System Management initialisiert")
|
||||
@ -1,158 +0,0 @@
|
||||
#!/usr/bin/env python3.11
|
||||
"""
|
||||
System Utilities - Konsolidierte System-Hilfsfunktionen
|
||||
Zusammenfassung von performance_monitor, scheduler und init_db Funktionalitäten
|
||||
"""
|
||||
|
||||
from utils.logging_config import get_logger
|
||||
from utils.job_scheduler import scheduler
|
||||
from models import init_database, create_initial_admin
|
||||
|
||||
# Logger initialisieren
|
||||
logger = get_logger("system_utilities")
|
||||
|
||||
# ===== PERFORMANCE MONITORING =====
|
||||
|
||||
def init_performance_monitoring(app):
|
||||
"""
|
||||
Initialisiert Performance-Monitoring für die Flask-App
|
||||
|
||||
Args:
|
||||
app: Flask-App-Instanz
|
||||
"""
|
||||
try:
|
||||
# Basic Performance-Monitoring Setup
|
||||
logger.info("[PERF] Performance-Monitoring wird initialisiert...")
|
||||
|
||||
# Optional: Hier könnten weitere Performance-Monitoring-Tools integriert werden
|
||||
# Für Air-Gapped Environment halten wir es minimal
|
||||
|
||||
app.config['PERFORMANCE_MONITORING_ENABLED'] = True
|
||||
|
||||
logger.info("[PERF] ✅ Performance-Monitoring erfolgreich initialisiert")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"[PERF] ❌ Fehler bei Performance-Monitoring-Initialisierung: {str(e)}")
|
||||
app.config['PERFORMANCE_MONITORING_ENABLED'] = False
|
||||
|
||||
# ===== SCHEDULER UTILITIES =====
|
||||
|
||||
def scheduler_is_running():
|
||||
"""
|
||||
Überprüft, ob der Job-Scheduler läuft.
|
||||
|
||||
Returns:
|
||||
bool: True wenn der Scheduler aktiv ist, sonst False
|
||||
"""
|
||||
return scheduler.is_running()
|
||||
|
||||
def start_scheduler():
|
||||
"""
|
||||
Startet den Job-Scheduler.
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich gestartet, False wenn bereits läuft
|
||||
"""
|
||||
return scheduler.start()
|
||||
|
||||
def stop_scheduler():
|
||||
"""
|
||||
Stoppt den Job-Scheduler.
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich gestoppt, False wenn nicht läuft
|
||||
"""
|
||||
return scheduler.stop()
|
||||
|
||||
def get_scheduler_uptime():
|
||||
"""
|
||||
Gibt die Laufzeit des Schedulers zurück.
|
||||
|
||||
Returns:
|
||||
str: Formatierte Laufzeit oder None, wenn der Scheduler nicht läuft
|
||||
"""
|
||||
return scheduler.get_uptime()
|
||||
|
||||
def get_scheduler_tasks():
|
||||
"""
|
||||
Gibt alle registrierten Tasks im Scheduler zurück.
|
||||
|
||||
Returns:
|
||||
dict: Dictionary mit Task-IDs als Schlüssel und Task-Konfigurationen als Werte
|
||||
"""
|
||||
return scheduler.get_tasks()
|
||||
|
||||
# ===== DATABASE INITIALIZATION =====
|
||||
|
||||
def initialize_database_with_admin():
|
||||
"""
|
||||
Initialisiert die Datenbank und erstellt einen initialen Admin-Benutzer.
|
||||
|
||||
Returns:
|
||||
bool: True wenn erfolgreich, False bei Fehlern
|
||||
"""
|
||||
try:
|
||||
logger.info("Initialisiere Datenbank...")
|
||||
init_database()
|
||||
|
||||
logger.info("Erstelle initialen Admin-Benutzer...")
|
||||
success = create_initial_admin(
|
||||
email="admin@mercedes-benz.com",
|
||||
password="744563017196A",
|
||||
name="System Administrator",
|
||||
username="admin"
|
||||
)
|
||||
|
||||
if success:
|
||||
logger.info("Admin-Benutzer erfolgreich erstellt.")
|
||||
logger.info("Login-Daten: Benutzername: admin, Passwort: 744563017196A")
|
||||
else:
|
||||
logger.warning("Admin-Benutzer konnte nicht erstellt werden (existiert bereits?).")
|
||||
|
||||
logger.info("Datenbank-Initialisierung abgeschlossen.")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Datenbank-Initialisierung: {str(e)}")
|
||||
return False
|
||||
|
||||
# ===== SYSTEM STATUS =====
|
||||
|
||||
def get_system_status():
|
||||
"""
|
||||
Gibt den aktuellen System-Status zurück.
|
||||
|
||||
Returns:
|
||||
dict: System-Status-Informationen
|
||||
"""
|
||||
return {
|
||||
'scheduler_running': scheduler_is_running(),
|
||||
'scheduler_uptime': get_scheduler_uptime(),
|
||||
'scheduler_tasks': len(get_scheduler_tasks()) if get_scheduler_tasks() else 0,
|
||||
'performance_monitoring': True # Immer aktiviert in dieser Version
|
||||
}
|
||||
|
||||
# ===== CLI INTERFACE =====
|
||||
|
||||
if __name__ == "__main__":
|
||||
import sys
|
||||
|
||||
if len(sys.argv) > 1:
|
||||
command = sys.argv[1]
|
||||
|
||||
if command == "init-db":
|
||||
initialize_database_with_admin()
|
||||
elif command == "status":
|
||||
status = get_system_status()
|
||||
print("=== System Status ===")
|
||||
print(f"Scheduler läuft: {'✅' if status['scheduler_running'] else '❌'}")
|
||||
print(f"Scheduler Uptime: {status['scheduler_uptime'] or 'N/A'}")
|
||||
print(f"Scheduler Tasks: {status['scheduler_tasks']}")
|
||||
print(f"Performance Monitoring: {'✅' if status['performance_monitoring'] else '❌'}")
|
||||
else:
|
||||
print("Verfügbare Kommandos:")
|
||||
print(" init-db - Initialisiert Datenbank mit Admin-Benutzer")
|
||||
print(" status - Zeigt System-Status an")
|
||||
else:
|
||||
print("Verwendung: python3.11 system_utilities.py <command>")
|
||||
print("Verfügbare Kommandos: init-db, status")
|
||||
@ -1,507 +0,0 @@
|
||||
"""
|
||||
Template Helpers für MYP Platform
|
||||
Jinja2 Helper-Funktionen für UI-Komponenten
|
||||
"""
|
||||
|
||||
from flask import current_app, url_for, request
|
||||
from markupsafe import Markup
|
||||
import json
|
||||
from datetime import datetime
|
||||
from typing import Dict, Any, Optional, List
|
||||
import calendar
|
||||
import random
|
||||
|
||||
|
||||
class UIHelpers:
|
||||
"""UI-Helper-Klasse für Template-Funktionen"""
|
||||
|
||||
@staticmethod
|
||||
def component_button(text: str, type: str = "primary", size: str = "md",
|
||||
classes: str = "", icon: str = "", onclick: str = "",
|
||||
disabled: bool = False, **attrs) -> Markup:
|
||||
"""
|
||||
Erstellt einen Button mit Tailwind-Klassen
|
||||
|
||||
Args:
|
||||
text: Button-Text
|
||||
type: Button-Typ (primary, secondary, danger, success)
|
||||
size: Button-Größe (sm, md, lg)
|
||||
classes: Zusätzliche CSS-Klassen
|
||||
icon: SVG-Icon-Code
|
||||
onclick: JavaScript-Code für onclick
|
||||
disabled: Button deaktiviert
|
||||
**attrs: Zusätzliche HTML-Attribute
|
||||
"""
|
||||
base_classes = ["btn"]
|
||||
|
||||
# Typ-spezifische Klassen
|
||||
type_classes = {
|
||||
"primary": "btn-primary",
|
||||
"secondary": "btn-secondary",
|
||||
"danger": "btn-danger",
|
||||
"success": "btn-success"
|
||||
}
|
||||
base_classes.append(type_classes.get(type, "btn-primary"))
|
||||
|
||||
# Größen-spezifische Klassen
|
||||
size_classes = {
|
||||
"sm": "btn-sm",
|
||||
"md": "",
|
||||
"lg": "btn-lg"
|
||||
}
|
||||
if size_classes.get(size):
|
||||
base_classes.append(size_classes[size])
|
||||
|
||||
if disabled:
|
||||
base_classes.append("opacity-50 cursor-not-allowed")
|
||||
|
||||
# Zusätzliche Klassen hinzufügen
|
||||
if classes:
|
||||
base_classes.append(classes)
|
||||
|
||||
# HTML-Attribute aufbauen
|
||||
attrs_str = ""
|
||||
for key, value in attrs.items():
|
||||
attrs_str += f' {key.replace("_", "-")}="{value}"'
|
||||
|
||||
if onclick:
|
||||
attrs_str += f' onclick="{onclick}"'
|
||||
|
||||
if disabled:
|
||||
attrs_str += ' disabled'
|
||||
|
||||
# Icon und Text kombinieren
|
||||
content = ""
|
||||
if icon:
|
||||
content += f'<span class="inline-block mr-2">{icon}</span>'
|
||||
content += text
|
||||
|
||||
html = f'''<button class="{" ".join(base_classes)}"{attrs_str}>
|
||||
{content}
|
||||
</button>'''
|
||||
|
||||
return Markup(html)
|
||||
|
||||
@staticmethod
|
||||
def component_badge(text: str, type: str = "blue", classes: str = "") -> Markup:
|
||||
"""
|
||||
Erstellt ein Badge/Tag-Element
|
||||
|
||||
Args:
|
||||
text: Badge-Text
|
||||
type: Badge-Typ (blue, green, red, yellow, purple)
|
||||
classes: Zusätzliche CSS-Klassen
|
||||
"""
|
||||
base_classes = ["badge", f"badge-{type}"]
|
||||
|
||||
if classes:
|
||||
base_classes.append(classes)
|
||||
|
||||
html = f'<span class="{" ".join(base_classes)}">{text}</span>'
|
||||
return Markup(html)
|
||||
|
||||
@staticmethod
|
||||
def component_status_badge(status: str, type: str = "job") -> Markup:
|
||||
"""
|
||||
Erstellt ein Status-Badge für Jobs oder Drucker
|
||||
|
||||
Args:
|
||||
status: Status-Wert
|
||||
type: Typ (job, printer)
|
||||
"""
|
||||
if type == "job":
|
||||
class_name = f"job-status job-{status}"
|
||||
else:
|
||||
class_name = f"printer-status printer-{status}"
|
||||
|
||||
# Status-Text übersetzen
|
||||
translations = {
|
||||
"job": {
|
||||
"queued": "In Warteschlange",
|
||||
"printing": "Wird gedruckt",
|
||||
"completed": "Abgeschlossen",
|
||||
"failed": "Fehlgeschlagen",
|
||||
"cancelled": "Abgebrochen",
|
||||
"paused": "Pausiert"
|
||||
},
|
||||
"printer": {
|
||||
"ready": "Bereit",
|
||||
"busy": "Beschäftigt",
|
||||
"error": "Fehler",
|
||||
"offline": "Offline",
|
||||
"maintenance": "Wartung"
|
||||
}
|
||||
}
|
||||
|
||||
display_text = translations.get(type, {}).get(status, status)
|
||||
|
||||
html = f'<span class="{class_name}">{display_text}</span>'
|
||||
return Markup(html)
|
||||
|
||||
@staticmethod
|
||||
def component_card(title: str = "", content: str = "", footer: str = "",
|
||||
classes: str = "", hover: bool = False) -> Markup:
|
||||
"""
|
||||
Erstellt eine Karte
|
||||
|
||||
Args:
|
||||
title: Karten-Titel
|
||||
content: Karten-Inhalt
|
||||
footer: Karten-Footer
|
||||
classes: Zusätzliche CSS-Klassen
|
||||
hover: Hover-Effekt aktivieren
|
||||
"""
|
||||
base_classes = ["card"]
|
||||
|
||||
if hover:
|
||||
base_classes.append("card-hover")
|
||||
|
||||
if classes:
|
||||
base_classes.append(classes)
|
||||
|
||||
html_parts = [f'<div class="{" ".join(base_classes)}">']
|
||||
|
||||
if title:
|
||||
html_parts.append(f'<h3 class="text-lg font-semibold mb-4 text-slate-900 dark:text-white">{title}</h3>')
|
||||
|
||||
if content:
|
||||
html_parts.append(f'<div class="text-slate-600 dark:text-slate-300">{content}</div>')
|
||||
|
||||
if footer:
|
||||
html_parts.append(f'<div class="mt-4 pt-4 border-t border-light-border dark:border-dark-border">{footer}</div>')
|
||||
|
||||
html_parts.append('</div>')
|
||||
|
||||
return Markup("".join(html_parts))
|
||||
|
||||
@staticmethod
|
||||
def component_alert(message: str, type: str = "info", dismissible: bool = False) -> Markup:
|
||||
"""
|
||||
Erstellt eine Alert-Benachrichtigung
|
||||
|
||||
Args:
|
||||
message: Alert-Nachricht
|
||||
type: Alert-Typ (info, success, warning, error)
|
||||
dismissible: Schließbar machen
|
||||
"""
|
||||
base_classes = ["alert", f"alert-{type}"]
|
||||
|
||||
html_parts = [f'<div class="{" ".join(base_classes)}">']
|
||||
|
||||
if dismissible:
|
||||
html_parts.append('''
|
||||
<div class="flex justify-between">
|
||||
<div>
|
||||
''')
|
||||
|
||||
html_parts.append(f'<p>{message}</p>')
|
||||
|
||||
if dismissible:
|
||||
html_parts.append('''
|
||||
</div>
|
||||
<button onclick="this.parentElement.parentElement.remove()"
|
||||
class="text-current opacity-70 hover:opacity-100">
|
||||
<svg class="w-4 h-4" fill="currentColor" viewBox="0 0 20 20">
|
||||
<path fill-rule="evenodd" d="M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z" clip-rule="evenodd"></path>
|
||||
</svg>
|
||||
</button>
|
||||
</div>
|
||||
''')
|
||||
|
||||
html_parts.append('</div>')
|
||||
|
||||
return Markup("".join(html_parts))
|
||||
|
||||
@staticmethod
|
||||
def component_modal(modal_id: str, title: str, content: str,
|
||||
footer: str = "", size: str = "md") -> Markup:
|
||||
"""
|
||||
Erstellt ein Modal-Dialog
|
||||
|
||||
Args:
|
||||
modal_id: Eindeutige Modal-ID
|
||||
title: Modal-Titel
|
||||
content: Modal-Inhalt
|
||||
footer: Modal-Footer
|
||||
size: Modal-Größe (sm, md, lg, xl)
|
||||
"""
|
||||
size_classes = {
|
||||
"sm": "max-w-md",
|
||||
"md": "max-w-lg",
|
||||
"lg": "max-w-2xl",
|
||||
"xl": "max-w-4xl"
|
||||
}
|
||||
|
||||
max_width = size_classes.get(size, "max-w-lg")
|
||||
|
||||
html = f'''
|
||||
<div id="{modal_id}" class="fixed inset-0 z-50 hidden">
|
||||
<div class="flex items-center justify-center min-h-screen px-4">
|
||||
<div class="modal-content bg-white dark:bg-slate-800 rounded-lg shadow-xl transform scale-95 opacity-0 transition-all duration-150 w-full {max_width}">
|
||||
<div class="px-6 py-4 border-b border-slate-200 dark:border-slate-700">
|
||||
<div class="flex items-center justify-between">
|
||||
<h3 class="text-lg font-semibold text-slate-900 dark:text-white">{title}</h3>
|
||||
<button data-modal-close="{modal_id}" class="text-slate-400 hover:text-slate-600 dark:hover:text-slate-300">
|
||||
<svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
|
||||
<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
|
||||
</svg>
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="px-6 py-4">
|
||||
{content}
|
||||
</div>
|
||||
{f'<div class="px-6 py-4 border-t border-slate-200 dark:border-slate-700">{footer}</div>' if footer else ''}
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
'''
|
||||
|
||||
return Markup(html)
|
||||
|
||||
@staticmethod
|
||||
def component_table(headers: List[str], rows: List[List[str]],
|
||||
classes: str = "", striped: bool = True) -> Markup:
|
||||
"""
|
||||
Erstellt eine styled Tabelle
|
||||
|
||||
Args:
|
||||
headers: Tabellen-Kopfzeilen
|
||||
rows: Tabellen-Zeilen
|
||||
classes: Zusätzliche CSS-Klassen
|
||||
striped: Zebra-Streifen aktivieren
|
||||
"""
|
||||
html_parts = ['<div class="table-container">']
|
||||
|
||||
table_classes = ["table-styled"]
|
||||
if classes:
|
||||
table_classes.append(classes)
|
||||
|
||||
html_parts.append(f'<table class="{" ".join(table_classes)}">')
|
||||
|
||||
# Kopfzeilen
|
||||
html_parts.append('<thead><tr>')
|
||||
for header in headers:
|
||||
html_parts.append(f'<th>{header}</th>')
|
||||
html_parts.append('</tr></thead>')
|
||||
|
||||
# Zeilen
|
||||
html_parts.append('<tbody>')
|
||||
for i, row in enumerate(rows):
|
||||
row_classes = ""
|
||||
if striped and i % 2 == 1:
|
||||
row_classes = 'class="bg-slate-50 dark:bg-slate-800/50"'
|
||||
html_parts.append(f'<tr {row_classes}>')
|
||||
for cell in row:
|
||||
html_parts.append(f'<td>{cell}</td>')
|
||||
html_parts.append('</tr>')
|
||||
html_parts.append('</tbody>')
|
||||
|
||||
html_parts.append('</table></div>')
|
||||
|
||||
return Markup("".join(html_parts))
|
||||
|
||||
@staticmethod
|
||||
def format_datetime_german(dt: datetime, format_str: str = "%d.%m.%Y %H:%M") -> str:
|
||||
"""
|
||||
Formatiert Datetime für deutsche Anzeige
|
||||
|
||||
Args:
|
||||
dt: Datetime-Objekt
|
||||
format_str: Format-String
|
||||
"""
|
||||
if not dt:
|
||||
return ""
|
||||
return dt.strftime(format_str)
|
||||
|
||||
@staticmethod
|
||||
def format_duration(minutes: int) -> str:
|
||||
"""
|
||||
Formatiert Dauer in Minuten zu lesbarem Format
|
||||
|
||||
Args:
|
||||
minutes: Dauer in Minuten
|
||||
"""
|
||||
if not minutes:
|
||||
return "0 Min"
|
||||
|
||||
if minutes < 60:
|
||||
return f"{minutes} Min"
|
||||
|
||||
hours = minutes // 60
|
||||
remaining_minutes = minutes % 60
|
||||
|
||||
if remaining_minutes == 0:
|
||||
return f"{hours} Std"
|
||||
|
||||
return f"{hours} Std {remaining_minutes} Min"
|
||||
|
||||
@staticmethod
|
||||
def json_encode(data: Any) -> str:
|
||||
"""
|
||||
Enkodiert Python-Daten als JSON für JavaScript
|
||||
|
||||
Args:
|
||||
data: Zu enkodierendes Objekt
|
||||
"""
|
||||
return json.dumps(data, default=str, ensure_ascii=False)
|
||||
|
||||
|
||||
def register_template_helpers(app):
|
||||
"""
|
||||
Registriert alle Template-Helper bei der Flask-App
|
||||
|
||||
Args:
|
||||
app: Flask-App-Instanz
|
||||
"""
|
||||
# Funktionen registrieren
|
||||
app.jinja_env.globals['ui_button'] = UIHelpers.component_button
|
||||
app.jinja_env.globals['ui_badge'] = UIHelpers.component_badge
|
||||
app.jinja_env.globals['ui_status_badge'] = UIHelpers.component_status_badge
|
||||
app.jinja_env.globals['ui_card'] = UIHelpers.component_card
|
||||
app.jinja_env.globals['ui_alert'] = UIHelpers.component_alert
|
||||
app.jinja_env.globals['ui_modal'] = UIHelpers.component_modal
|
||||
app.jinja_env.globals['ui_table'] = UIHelpers.component_table
|
||||
|
||||
# Filter registrieren
|
||||
app.jinja_env.filters['german_datetime'] = UIHelpers.format_datetime_german
|
||||
app.jinja_env.filters['duration'] = UIHelpers.format_duration
|
||||
app.jinja_env.filters['json'] = UIHelpers.json_encode
|
||||
|
||||
# Zusätzliche globale Variablen
|
||||
app.jinja_env.globals['current_year'] = datetime.now().year
|
||||
|
||||
# Icons als globale Variablen
|
||||
icons = {
|
||||
'check': '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 13l4 4L19 7"></path></svg>',
|
||||
'x': '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path></svg>',
|
||||
'plus': '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 6v6m0 0v6m0-6h6m-6 0H6"></path></svg>',
|
||||
'edit': '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z"></path></svg>',
|
||||
'trash': '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"></path></svg>',
|
||||
'printer': '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M17 17h2a2 2 0 002-2v-4a2 2 0 00-2-2H5a2 2 0 00-2 2v4a2 2 0 002 2h2m2 4h6a2 2 0 002-2v-4a2 2 0 00-2-2H9a2 2 0 00-2 2v4a2 2 0 002 2zm8-12V5a2 2 0 00-2-2H9a2 2 0 00-2 2v4h10z"></path></svg>',
|
||||
'dashboard': '<svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24"><path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M3 7v10a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2H5a2 2 0 00-2-2z"></path></svg>',
|
||||
}
|
||||
|
||||
app.jinja_env.globals['icons'] = icons
|
||||
|
||||
@app.context_processor
|
||||
def utility_processor():
|
||||
"""Fügt nützliche Hilfsfunktionen zu Jinja hinzu."""
|
||||
return dict(
|
||||
active_page=active_page,
|
||||
format_datetime=format_datetime,
|
||||
format_date=format_date,
|
||||
format_time=format_time,
|
||||
random_avatar_color=random_avatar_color,
|
||||
get_initials=get_initials,
|
||||
render_progress_bar=render_progress_bar
|
||||
)
|
||||
|
||||
def active_page(path):
|
||||
"""
|
||||
Überprüft, ob der aktuelle Pfad mit dem gegebenen Pfad übereinstimmt.
|
||||
"""
|
||||
if request.path == path:
|
||||
return 'active'
|
||||
return ''
|
||||
|
||||
def format_datetime(value, format='%d.%m.%Y %H:%M'):
|
||||
"""
|
||||
Formatiert ein Datum mit Uhrzeit nach deutschem Format.
|
||||
"""
|
||||
if value is None:
|
||||
return ""
|
||||
if isinstance(value, str):
|
||||
try:
|
||||
value = datetime.fromisoformat(value)
|
||||
except ValueError:
|
||||
return value
|
||||
return value.strftime(format)
|
||||
|
||||
def format_date(value, format='%d.%m.%Y'):
|
||||
"""
|
||||
Formatiert ein Datum nach deutschem Format.
|
||||
"""
|
||||
if value is None:
|
||||
return ""
|
||||
if isinstance(value, str):
|
||||
try:
|
||||
value = datetime.fromisoformat(value)
|
||||
except ValueError:
|
||||
return value
|
||||
return value.strftime(format)
|
||||
|
||||
def format_time(value, format='%H:%M'):
|
||||
"""
|
||||
Formatiert eine Uhrzeit nach deutschem Format.
|
||||
"""
|
||||
if value is None:
|
||||
return ""
|
||||
if isinstance(value, str):
|
||||
try:
|
||||
value = datetime.fromisoformat(value)
|
||||
except ValueError:
|
||||
return value
|
||||
return value.strftime(format)
|
||||
|
||||
def random_avatar_color():
|
||||
"""
|
||||
Gibt eine zufällige Hintergrundfarbe für Avatare zurück.
|
||||
"""
|
||||
colors = [
|
||||
'bg-blue-100 text-blue-800',
|
||||
'bg-green-100 text-green-800',
|
||||
'bg-yellow-100 text-yellow-800',
|
||||
'bg-red-100 text-red-800',
|
||||
'bg-indigo-100 text-indigo-800',
|
||||
'bg-purple-100 text-purple-800',
|
||||
'bg-pink-100 text-pink-800',
|
||||
'bg-gray-100 text-gray-800',
|
||||
]
|
||||
return random.choice(colors)
|
||||
|
||||
def get_initials(name, max_length=2):
|
||||
"""
|
||||
Extrahiert die Initialen eines Namens.
|
||||
"""
|
||||
if not name:
|
||||
return "?"
|
||||
|
||||
parts = name.split()
|
||||
if len(parts) == 1:
|
||||
return name[0:max_length].upper()
|
||||
|
||||
initials = ""
|
||||
for part in parts:
|
||||
if part and len(initials) < max_length:
|
||||
initials += part[0].upper()
|
||||
|
||||
return initials
|
||||
|
||||
def render_progress_bar(value, color='blue'):
|
||||
"""
|
||||
Rendert einen Fortschrittsbalken ohne Inline-Styles.
|
||||
|
||||
Args:
|
||||
value (int): Der Prozentwert für den Fortschrittsbalken (0-100)
|
||||
color (str): Die Farbe des Balkens (blue, green, purple, red)
|
||||
|
||||
Returns:
|
||||
str: HTML-Markup für den Fortschrittsbalken
|
||||
"""
|
||||
css_class = f"progress-bar-fill-{color}"
|
||||
|
||||
# Sicherstellen, dass der Wert im gültigen Bereich liegt
|
||||
if value < 0:
|
||||
value = 0
|
||||
elif value > 100:
|
||||
value = 100
|
||||
|
||||
# Erstellen des DOM-Struktur für den Fortschrittsbalken
|
||||
html = f"""
|
||||
<div class="progress-bar">
|
||||
<div class="progress-bar-fill {css_class}" data-width="{value}"></div>
|
||||
</div>
|
||||
"""
|
||||
|
||||
return Markup(html)
|
||||
@ -1,437 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
# -*- coding: utf-8 -*-
|
||||
"""
|
||||
Umfassender Systemfunktionalitätstest für MYP Platform
|
||||
Prüft alle kritischen Komponenten und Features
|
||||
"""
|
||||
|
||||
import sys
|
||||
import os
|
||||
import json
|
||||
import requests
|
||||
import time
|
||||
from datetime import datetime
|
||||
from typing import Dict, List, Any
|
||||
|
||||
# Füge das aktuelle Verzeichnis zum Python-Pfad hinzu
|
||||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
# Tests für interne Komponenten
|
||||
def test_internal_components():
|
||||
"""Testet interne Systemkomponenten"""
|
||||
results = {}
|
||||
|
||||
print("🔍 Teste interne Systemkomponenten...")
|
||||
|
||||
# Test 1: Importiere kritische Module
|
||||
try:
|
||||
from models import User, Printer, Job, get_db_session, init_database
|
||||
from utils.settings import SECRET_KEY, DATABASE_PATH
|
||||
from utils.logging_config import get_logger
|
||||
results["module_imports"] = {"status": "SUCCESS", "message": "Alle kritischen Module importiert"}
|
||||
except Exception as e:
|
||||
results["module_imports"] = {"status": "FAILED", "message": f"Import-Fehler: {str(e)}"}
|
||||
return results
|
||||
|
||||
# Test 2: Datenbankverbindung
|
||||
try:
|
||||
db_session = get_db_session()
|
||||
user_count = db_session.query(User).count()
|
||||
printer_count = db_session.query(Printer).count()
|
||||
job_count = db_session.query(Job).count()
|
||||
db_session.close()
|
||||
|
||||
results["database_connection"] = {
|
||||
"status": "SUCCESS",
|
||||
"message": f"Datenbank verbunden - {user_count} Benutzer, {printer_count} Drucker, {job_count} Jobs"
|
||||
}
|
||||
except Exception as e:
|
||||
results["database_connection"] = {"status": "FAILED", "message": f"DB-Fehler: {str(e)}"}
|
||||
|
||||
# Test 3: Admin-Benutzer vorhanden
|
||||
try:
|
||||
db_session = get_db_session()
|
||||
admin_user = db_session.query(User).filter(User.role == "admin").first()
|
||||
db_session.close()
|
||||
|
||||
if admin_user:
|
||||
results["admin_user"] = {
|
||||
"status": "SUCCESS",
|
||||
"message": f"Admin-Benutzer gefunden: {admin_user.username} ({admin_user.email})"
|
||||
}
|
||||
else:
|
||||
results["admin_user"] = {"status": "FAILED", "message": "Kein Admin-Benutzer gefunden"}
|
||||
except Exception as e:
|
||||
results["admin_user"] = {"status": "FAILED", "message": f"Admin-Check-Fehler: {str(e)}"}
|
||||
|
||||
# Test 4: Windows-Fixes
|
||||
try:
|
||||
if os.name == 'nt':
|
||||
from utils.windows_fixes import get_windows_thread_manager
|
||||
thread_manager = get_windows_thread_manager()
|
||||
if thread_manager:
|
||||
results["windows_fixes"] = {"status": "SUCCESS", "message": "Windows-Fixes geladen"}
|
||||
else:
|
||||
results["windows_fixes"] = {"status": "WARNING", "message": "Windows-Fixes verfügbar aber nicht aktiv"}
|
||||
else:
|
||||
results["windows_fixes"] = {"status": "SKIPPED", "message": "Nicht Windows-System"}
|
||||
except Exception as e:
|
||||
results["windows_fixes"] = {"status": "WARNING", "message": f"Windows-Fixes-Fehler: {str(e)}"}
|
||||
|
||||
# Test 5: Logging-System
|
||||
try:
|
||||
logger = get_logger("test")
|
||||
logger.info("Test-Log-Nachricht")
|
||||
results["logging_system"] = {"status": "SUCCESS", "message": "Logging-System funktional"}
|
||||
except Exception as e:
|
||||
results["logging_system"] = {"status": "FAILED", "message": f"Logging-Fehler: {str(e)}"}
|
||||
|
||||
# Test 6: Queue Manager
|
||||
try:
|
||||
from utils.queue_manager import get_queue_manager
|
||||
queue_manager = get_queue_manager()
|
||||
if queue_manager:
|
||||
status = queue_manager.get_queue_status()
|
||||
results["queue_manager"] = {
|
||||
"status": "SUCCESS",
|
||||
"message": f"Queue Manager aktiv - Status: {len(status)} Warteschlangen"
|
||||
}
|
||||
else:
|
||||
results["queue_manager"] = {"status": "WARNING", "message": "Queue Manager nicht initialisiert"}
|
||||
except Exception as e:
|
||||
results["queue_manager"] = {"status": "WARNING", "message": f"Queue Manager-Fehler: {str(e)}"}
|
||||
|
||||
# Test 7: Job Scheduler
|
||||
try:
|
||||
from utils.job_scheduler import get_job_scheduler
|
||||
scheduler = get_job_scheduler()
|
||||
if scheduler:
|
||||
results["job_scheduler"] = {"status": "SUCCESS", "message": "Job Scheduler verfügbar"}
|
||||
else:
|
||||
results["job_scheduler"] = {"status": "WARNING", "message": "Job Scheduler nicht verfügbar"}
|
||||
except Exception as e:
|
||||
results["job_scheduler"] = {"status": "WARNING", "message": f"Job Scheduler-Fehler: {str(e)}"}
|
||||
|
||||
return results
|
||||
|
||||
def test_api_endpoints():
|
||||
"""Testet kritische API-Endpunkte"""
|
||||
results = {}
|
||||
base_url = "http://localhost:5000"
|
||||
|
||||
print("🌐 Teste API-Endpunkte...")
|
||||
|
||||
# Test 1: Root-Endpunkt
|
||||
try:
|
||||
response = requests.get(f"{base_url}/", timeout=5)
|
||||
if response.status_code == 200:
|
||||
results["root_endpoint"] = {"status": "SUCCESS", "message": "Root-Endpunkt erreichbar"}
|
||||
else:
|
||||
results["root_endpoint"] = {"status": "FAILED", "message": f"HTTP {response.status_code}"}
|
||||
except Exception as e:
|
||||
results["root_endpoint"] = {"status": "FAILED", "message": f"Verbindungsfehler: {str(e)}"}
|
||||
|
||||
# Test 2: Login-Seite
|
||||
try:
|
||||
response = requests.get(f"{base_url}/auth/login", timeout=5)
|
||||
if response.status_code == 200:
|
||||
results["login_page"] = {"status": "SUCCESS", "message": "Login-Seite verfügbar"}
|
||||
else:
|
||||
results["login_page"] = {"status": "FAILED", "message": f"HTTP {response.status_code}"}
|
||||
except Exception as e:
|
||||
results["login_page"] = {"status": "FAILED", "message": f"Login-Seite-Fehler: {str(e)}"}
|
||||
|
||||
# Test 3: API Status (ohne Authentifizierung)
|
||||
try:
|
||||
response = requests.get(f"{base_url}/api/kiosk/status", timeout=5)
|
||||
if response.status_code in [200, 401, 403]: # Diese sind alle erwartete Responses
|
||||
results["api_status"] = {"status": "SUCCESS", "message": "API grundsätzlich erreichbar"}
|
||||
else:
|
||||
results["api_status"] = {"status": "WARNING", "message": f"Unerwarteter HTTP {response.status_code}"}
|
||||
except Exception as e:
|
||||
results["api_status"] = {"status": "FAILED", "message": f"API-Status-Fehler: {str(e)}"}
|
||||
|
||||
return results
|
||||
|
||||
def test_file_structure():
|
||||
"""Testet die Datei- und Verzeichnisstruktur"""
|
||||
results = {}
|
||||
|
||||
print("📁 Teste Datei- und Verzeichnisstruktur...")
|
||||
|
||||
# Kritische Dateien
|
||||
critical_files = [
|
||||
"app.py",
|
||||
"models.py",
|
||||
"config/settings.py",
|
||||
"templates/base.html",
|
||||
"templates/login.html",
|
||||
"templates/dashboard.html",
|
||||
"static/css",
|
||||
"static/js",
|
||||
"utils/logging_config.py",
|
||||
"utils/queue_manager.py",
|
||||
"blueprints/guest.py",
|
||||
"blueprints/users.py",
|
||||
"blueprints/calendar.py"
|
||||
]
|
||||
|
||||
missing_files = []
|
||||
present_files = []
|
||||
|
||||
for file_path in critical_files:
|
||||
if os.path.exists(file_path):
|
||||
present_files.append(file_path)
|
||||
else:
|
||||
missing_files.append(file_path)
|
||||
|
||||
if missing_files:
|
||||
results["file_structure"] = {
|
||||
"status": "WARNING",
|
||||
"message": f"Fehlende Dateien: {', '.join(missing_files)}"
|
||||
}
|
||||
else:
|
||||
results["file_structure"] = {
|
||||
"status": "SUCCESS",
|
||||
"message": f"Alle {len(present_files)} kritischen Dateien vorhanden"
|
||||
}
|
||||
|
||||
# Verzeichnisse
|
||||
critical_dirs = ["logs", "database", "uploads", "static", "templates", "utils", "config", "blueprints"]
|
||||
missing_dirs = []
|
||||
present_dirs = []
|
||||
|
||||
for dir_path in critical_dirs:
|
||||
if os.path.exists(dir_path) and os.path.isdir(dir_path):
|
||||
present_dirs.append(dir_path)
|
||||
else:
|
||||
missing_dirs.append(dir_path)
|
||||
|
||||
if missing_dirs:
|
||||
results["directory_structure"] = {
|
||||
"status": "WARNING",
|
||||
"message": f"Fehlende Verzeichnisse: {', '.join(missing_dirs)}"
|
||||
}
|
||||
else:
|
||||
results["directory_structure"] = {
|
||||
"status": "SUCCESS",
|
||||
"message": f"Alle {len(present_dirs)} kritischen Verzeichnisse vorhanden"
|
||||
}
|
||||
|
||||
return results
|
||||
|
||||
def test_database_integrity():
|
||||
"""Testet die Datenbankintegrität"""
|
||||
results = {}
|
||||
|
||||
print("🗄️ Teste Datenbankintegrität...")
|
||||
|
||||
try:
|
||||
from models import User, Printer, Job, Stats, SystemLog, GuestRequest, UserPermission, Notification, get_db_session
|
||||
|
||||
db_session = get_db_session()
|
||||
|
||||
# Test Tabellen-Existenz
|
||||
tables_test = {}
|
||||
models_to_test = [User, Printer, Job, Stats, SystemLog, GuestRequest, UserPermission, Notification]
|
||||
|
||||
for model in models_to_test:
|
||||
try:
|
||||
count = db_session.query(model).count()
|
||||
tables_test[model.__tablename__] = {"exists": True, "count": count}
|
||||
except Exception as e:
|
||||
tables_test[model.__tablename__] = {"exists": False, "error": str(e)}
|
||||
|
||||
existing_tables = sum(1 for t in tables_test.values() if t.get("exists"))
|
||||
total_tables = len(tables_test)
|
||||
|
||||
if existing_tables == total_tables:
|
||||
results["table_integrity"] = {
|
||||
"status": "SUCCESS",
|
||||
"message": f"Alle {total_tables} Tabellen existieren und sind zugänglich"
|
||||
}
|
||||
else:
|
||||
results["table_integrity"] = {
|
||||
"status": "FAILED",
|
||||
"message": f"Nur {existing_tables}/{total_tables} Tabellen zugänglich"
|
||||
}
|
||||
|
||||
# Test Datenbank-Constraints
|
||||
try:
|
||||
# Teste Foreign Key Constraints
|
||||
db_session.execute("PRAGMA foreign_key_check")
|
||||
results["database_constraints"] = {"status": "SUCCESS", "message": "Foreign Key Constraints OK"}
|
||||
except Exception as e:
|
||||
results["database_constraints"] = {"status": "WARNING", "message": f"Constraint-Check-Fehler: {str(e)}"}
|
||||
|
||||
db_session.close()
|
||||
|
||||
except Exception as e:
|
||||
results["database_integrity"] = {"status": "FAILED", "message": f"DB-Integritätstest fehlgeschlagen: {str(e)}"}
|
||||
|
||||
return results
|
||||
|
||||
def create_test_data():
|
||||
"""Erstellt Testdaten falls nötig"""
|
||||
results = {}
|
||||
|
||||
print("🧪 Erstelle Testdaten...")
|
||||
|
||||
try:
|
||||
from models import User, Printer, Job, get_db_session
|
||||
|
||||
db_session = get_db_session()
|
||||
|
||||
# Teste ob Testdrucker existieren
|
||||
test_printer = db_session.query(Printer).filter(Printer.name.like("Test%")).first()
|
||||
|
||||
if not test_printer:
|
||||
# Erstelle Test-Drucker
|
||||
test_printer = Printer(
|
||||
name="Test Drucker 1",
|
||||
model="Test Model",
|
||||
location="Test Labor",
|
||||
ip_address="192.168.1.100",
|
||||
mac_address="00:11:22:33:44:55",
|
||||
plug_ip="192.168.1.101",
|
||||
plug_username="test_user",
|
||||
plug_password="test_pass",
|
||||
status="offline"
|
||||
)
|
||||
db_session.add(test_printer)
|
||||
db_session.commit()
|
||||
|
||||
results["test_printer"] = {"status": "SUCCESS", "message": "Test-Drucker erstellt"}
|
||||
else:
|
||||
results["test_printer"] = {"status": "SUCCESS", "message": "Test-Drucker bereits vorhanden"}
|
||||
|
||||
# Teste ob Testbenutzer existiert
|
||||
test_user = db_session.query(User).filter(User.username == "testuser").first()
|
||||
|
||||
if not test_user:
|
||||
# Erstelle Test-Benutzer
|
||||
test_user = User(
|
||||
username="testuser",
|
||||
email="test@test.com",
|
||||
name="Test Benutzer",
|
||||
role="user"
|
||||
)
|
||||
test_user.set_password("testpass")
|
||||
db_session.add(test_user)
|
||||
db_session.commit()
|
||||
|
||||
results["test_user"] = {"status": "SUCCESS", "message": "Test-Benutzer erstellt"}
|
||||
else:
|
||||
results["test_user"] = {"status": "SUCCESS", "message": "Test-Benutzer bereits vorhanden"}
|
||||
|
||||
db_session.close()
|
||||
|
||||
except Exception as e:
|
||||
results["test_data_creation"] = {"status": "FAILED", "message": f"Test-Daten-Erstellung fehlgeschlagen: {str(e)}"}
|
||||
|
||||
return results
|
||||
|
||||
def run_comprehensive_test():
|
||||
"""Führt alle Tests aus und zeigt Ergebnisse an"""
|
||||
print("🚀 Starte umfassenden Systemfunktionalitätstest für MYP Platform\n")
|
||||
print("=" * 70)
|
||||
|
||||
all_results = {}
|
||||
|
||||
# Interne Komponenten
|
||||
all_results.update(test_internal_components())
|
||||
print()
|
||||
|
||||
# Datei-/Verzeichnisstruktur
|
||||
all_results.update(test_file_structure())
|
||||
print()
|
||||
|
||||
# Datenbankintegrität
|
||||
all_results.update(test_database_integrity())
|
||||
print()
|
||||
|
||||
# Testdaten erstellen
|
||||
all_results.update(create_test_data())
|
||||
print()
|
||||
|
||||
# API-Endpunkte (nur wenn Server läuft)
|
||||
all_results.update(test_api_endpoints())
|
||||
print()
|
||||
|
||||
# ergebnisse zusammenfassen
|
||||
print("=" * 70)
|
||||
print("📊 TESTERGEBNISSE ZUSAMMENFASSUNG")
|
||||
print("=" * 70)
|
||||
|
||||
success_count = 0
|
||||
warning_count = 0
|
||||
failed_count = 0
|
||||
skipped_count = 0
|
||||
|
||||
for test_name, result in all_results.items():
|
||||
status = result["status"]
|
||||
message = result["message"]
|
||||
|
||||
if status == "SUCCESS":
|
||||
print(f"✅ {test_name}: {message}")
|
||||
success_count += 1
|
||||
elif status == "WARNING":
|
||||
print(f"⚠️ {test_name}: {message}")
|
||||
warning_count += 1
|
||||
elif status == "FAILED":
|
||||
print(f"❌ {test_name}: {message}")
|
||||
failed_count += 1
|
||||
elif status == "SKIPPED":
|
||||
print(f"⏭️ {test_name}: {message}")
|
||||
skipped_count += 1
|
||||
|
||||
total_tests = len(all_results)
|
||||
|
||||
print("\n" + "=" * 70)
|
||||
print("📈 STATISTIKEN")
|
||||
print("=" * 70)
|
||||
print(f"Gesamt: {total_tests} Tests")
|
||||
print(f"✅ Erfolgreich: {success_count}")
|
||||
print(f"⚠️ Warnungen: {warning_count}")
|
||||
print(f"❌ Fehlgeschlagen: {failed_count}")
|
||||
print(f"⏭️ Übersprungen: {skipped_count}")
|
||||
|
||||
# Empfehlungen
|
||||
print("\n" + "=" * 70)
|
||||
print("💡 EMPFEHLUNGEN")
|
||||
print("=" * 70)
|
||||
|
||||
if failed_count == 0 and warning_count <= 2:
|
||||
print("🎉 System ist voll funktionsfähig!")
|
||||
print(" Alle kritischen Komponenten arbeiten ordnungsgemäß.")
|
||||
elif failed_count == 0:
|
||||
print("✅ System ist grundsätzlich funktionsfähig.")
|
||||
print(" Einige Warnungen sollten beachtet werden.")
|
||||
else:
|
||||
print("⚠️ System hat kritische Probleme.")
|
||||
print(" Fehlgeschlagene Tests müssen behoben werden.")
|
||||
|
||||
# Speichere Ergebnisse in JSON-Datei
|
||||
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
|
||||
results_file = f"test_results_{timestamp}.json"
|
||||
|
||||
with open(results_file, "w", encoding="utf-8") as f:
|
||||
json.dump({
|
||||
"timestamp": datetime.now().isoformat(),
|
||||
"summary": {
|
||||
"total": total_tests,
|
||||
"success": success_count,
|
||||
"warnings": warning_count,
|
||||
"failed": failed_count,
|
||||
"skipped": skipped_count
|
||||
},
|
||||
"detailed_results": all_results
|
||||
}, f, indent=2, ensure_ascii=False)
|
||||
|
||||
print(f"\n📄 Detaillierte Ergebnisse gespeichert in: {results_file}")
|
||||
|
||||
return failed_count == 0
|
||||
|
||||
if __name__ == "__main__":
|
||||
success = run_comprehensive_test()
|
||||
sys.exit(0 if success else 1)
|
||||
@ -1,675 +0,0 @@
|
||||
"""
|
||||
Timer-Manager für Countdown-Zähler mit Force-Quit-Funktionalität
|
||||
|
||||
Dieses Modul verwaltet System-Timer für verschiedene Anwendungsfälle:
|
||||
- Kiosk-Timer für automatische Session-Beendigung
|
||||
- Job-Timer für Druckaufträge mit Timeout
|
||||
- Session-Timer für Benutzerinaktivität
|
||||
- Wartungs-Timer für geplante System-Shutdowns
|
||||
|
||||
Autor: System
|
||||
Erstellt: 2025
|
||||
"""
|
||||
|
||||
import threading
|
||||
import time
|
||||
import json
|
||||
import logging
|
||||
from datetime import datetime, timedelta
|
||||
from typing import Dict, List, Optional, Callable, Any
|
||||
from enum import Enum
|
||||
from contextlib import contextmanager
|
||||
|
||||
from models import SystemTimer, get_db_session, get_cached_session
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
logger = get_logger("timer_manager")
|
||||
|
||||
class TimerType(Enum):
|
||||
"""Verfügbare Timer-Typen"""
|
||||
KIOSK = "kiosk"
|
||||
SESSION = "session"
|
||||
JOB = "job"
|
||||
SYSTEM = "system"
|
||||
MAINTENANCE = "maintenance"
|
||||
|
||||
class ForceQuitAction(Enum):
|
||||
"""Verfügbare Force-Quit-Aktionen"""
|
||||
LOGOUT = "logout"
|
||||
RESTART = "restart"
|
||||
SHUTDOWN = "shutdown"
|
||||
CUSTOM = "custom"
|
||||
|
||||
class TimerStatus(Enum):
|
||||
"""Timer-Status-Werte"""
|
||||
STOPPED = "stopped"
|
||||
RUNNING = "running"
|
||||
PAUSED = "paused"
|
||||
EXPIRED = "expired"
|
||||
FORCE_QUIT = "force_quit"
|
||||
|
||||
class TimerManager:
|
||||
"""
|
||||
Zentraler Timer-Manager für alle System-Timer.
|
||||
Verwaltet Timer-Instanzen und führt automatische Cleanup-Operationen durch.
|
||||
"""
|
||||
|
||||
def __init__(self):
|
||||
self._timers: Dict[str, SystemTimer] = {}
|
||||
self._timer_callbacks: Dict[str, List[Callable]] = {}
|
||||
self._force_quit_handlers: Dict[str, Callable] = {}
|
||||
self._background_thread: Optional[threading.Thread] = None
|
||||
self._shutdown_flag = threading.Event()
|
||||
self._update_interval = 1.0 # Sekunden zwischen Updates
|
||||
|
||||
# Standard Force-Quit-Handler registrieren
|
||||
self._register_default_handlers()
|
||||
|
||||
# Background-Thread für Timer-Updates starten
|
||||
self._start_background_thread()
|
||||
|
||||
logger.info("Timer-Manager initialisiert")
|
||||
|
||||
def _register_default_handlers(self):
|
||||
"""Registriert Standard-Handler für Force-Quit-Aktionen"""
|
||||
|
||||
def logout_handler(timer: SystemTimer) -> bool:
|
||||
"""Standard-Handler für Logout-Aktion"""
|
||||
try:
|
||||
logger.info(f"Logout-Handler für Timer '{timer.name}' ausgeführt")
|
||||
# Hier würde der tatsächliche Logout implementiert werden
|
||||
# Das wird in app.py über die API-Endpunkte gemacht
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler im Logout-Handler: {str(e)}")
|
||||
return False
|
||||
|
||||
def restart_handler(timer: SystemTimer) -> bool:
|
||||
"""Standard-Handler für System-Restart"""
|
||||
try:
|
||||
logger.warning(f"System-Restart durch Timer '{timer.name}' ausgelöst")
|
||||
# Implementierung würde über System-API erfolgen
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler im Restart-Handler: {str(e)}")
|
||||
return False
|
||||
|
||||
def shutdown_handler(timer: SystemTimer) -> bool:
|
||||
"""Standard-Handler für System-Shutdown"""
|
||||
try:
|
||||
logger.warning(f"System-Shutdown durch Timer '{timer.name}' ausgelöst")
|
||||
# Implementierung würde über System-API erfolgen
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler im Shutdown-Handler: {str(e)}")
|
||||
return False
|
||||
|
||||
# Handler registrieren
|
||||
self._force_quit_handlers[ForceQuitAction.LOGOUT.value] = logout_handler
|
||||
self._force_quit_handlers[ForceQuitAction.RESTART.value] = restart_handler
|
||||
self._force_quit_handlers[ForceQuitAction.SHUTDOWN.value] = shutdown_handler
|
||||
|
||||
def _start_background_thread(self):
|
||||
"""Startet den Background-Thread für Timer-Updates"""
|
||||
if self._background_thread is None or not self._background_thread.is_alive():
|
||||
self._background_thread = threading.Thread(
|
||||
target=self._background_worker,
|
||||
name="TimerManager-Background",
|
||||
daemon=True
|
||||
)
|
||||
self._background_thread.start()
|
||||
logger.debug("Background-Thread für Timer-Updates gestartet")
|
||||
|
||||
def _background_worker(self):
|
||||
"""Background-Worker für kontinuierliche Timer-Updates"""
|
||||
logger.debug("Timer-Manager Background-Worker gestartet")
|
||||
|
||||
while not self._shutdown_flag.is_set():
|
||||
try:
|
||||
self._update_all_timers()
|
||||
self._process_expired_timers()
|
||||
|
||||
# Warte bis zum nächsten Update
|
||||
self._shutdown_flag.wait(self._update_interval)
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler im Timer-Background-Worker: {str(e)}")
|
||||
time.sleep(5) # Kurze Pause bei Fehlern
|
||||
|
||||
logger.debug("Timer-Manager Background-Worker beendet")
|
||||
|
||||
def _update_all_timers(self):
|
||||
"""Aktualisiert alle Timer aus der Datenbank"""
|
||||
try:
|
||||
with get_cached_session() as session:
|
||||
# Lade alle aktiven Timer aus der Datenbank
|
||||
db_timers = session.query(SystemTimer).filter(
|
||||
SystemTimer.status.in_([TimerStatus.RUNNING.value, TimerStatus.PAUSED.value])
|
||||
).all()
|
||||
|
||||
# Update lokale Timer-Cache
|
||||
current_timer_names = set(self._timers.keys())
|
||||
db_timer_names = {timer.name for timer in db_timers}
|
||||
|
||||
# Entferne Timer die nicht mehr in der DB sind
|
||||
for name in current_timer_names - db_timer_names:
|
||||
if name in self._timers:
|
||||
del self._timers[name]
|
||||
logger.debug(f"Timer '{name}' aus lokalem Cache entfernt")
|
||||
|
||||
# Aktualisiere/füge Timer hinzu
|
||||
for timer in db_timers:
|
||||
self._timers[timer.name] = timer
|
||||
|
||||
# Callback-Funktionen aufrufen wenn verfügbar
|
||||
if timer.name in self._timer_callbacks:
|
||||
for callback in self._timer_callbacks[timer.name]:
|
||||
try:
|
||||
callback(timer)
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler in Timer-Callback für '{timer.name}': {str(e)}")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Update der Timer: {str(e)}")
|
||||
|
||||
def _process_expired_timers(self):
|
||||
"""Verarbeitet abgelaufene Timer und führt Force-Quit-Aktionen aus"""
|
||||
try:
|
||||
expired_timers = SystemTimer.get_expired_timers()
|
||||
|
||||
for timer in expired_timers:
|
||||
try:
|
||||
logger.warning(f"Timer '{timer.name}' ist abgelaufen - führe Force-Quit aus")
|
||||
|
||||
# Force-Quit-Aktion ausführen
|
||||
success = self._execute_force_quit(timer)
|
||||
|
||||
if success:
|
||||
# Timer als abgelaufen markieren
|
||||
with get_cached_session() as session:
|
||||
db_timer = session.query(SystemTimer).filter(
|
||||
SystemTimer.id == timer.id
|
||||
).first()
|
||||
|
||||
if db_timer:
|
||||
db_timer.status = TimerStatus.EXPIRED.value
|
||||
db_timer.updated_at = datetime.now()
|
||||
session.commit()
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Verarbeiten des abgelaufenen Timers '{timer.name}': {str(e)}")
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Verarbeiten abgelaufener Timer: {str(e)}")
|
||||
|
||||
def _execute_force_quit(self, timer: SystemTimer) -> bool:
|
||||
"""Führt die Force-Quit-Aktion für einen Timer aus"""
|
||||
try:
|
||||
action = timer.force_quit_action
|
||||
|
||||
# Custom-Endpoint prüfen
|
||||
if action == ForceQuitAction.CUSTOM.value and timer.custom_action_endpoint:
|
||||
return self._execute_custom_action(timer)
|
||||
|
||||
# Standard-Handler verwenden
|
||||
if action in self._force_quit_handlers:
|
||||
handler = self._force_quit_handlers[action]
|
||||
return handler(timer)
|
||||
|
||||
logger.warning(f"Unbekannte Force-Quit-Aktion: {action}")
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Ausführen der Force-Quit-Aktion für Timer '{timer.name}': {str(e)}")
|
||||
return False
|
||||
|
||||
def _execute_custom_action(self, timer: SystemTimer) -> bool:
|
||||
"""Führt eine benutzerdefinierte Force-Quit-Aktion aus"""
|
||||
try:
|
||||
# Hier würde ein HTTP-Request an den Custom-Endpoint gemacht werden
|
||||
# Das wird über die Flask-App-Routen implementiert
|
||||
logger.info(f"Custom-Action für Timer '{timer.name}': {timer.custom_action_endpoint}")
|
||||
return True
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler bei Custom-Action für Timer '{timer.name}': {str(e)}")
|
||||
return False
|
||||
|
||||
def create_timer(self, name: str, timer_type: TimerType, duration_seconds: int,
|
||||
force_quit_action: ForceQuitAction = ForceQuitAction.LOGOUT,
|
||||
auto_start: bool = False, **kwargs) -> Optional[SystemTimer]:
|
||||
"""
|
||||
Erstellt einen neuen Timer.
|
||||
|
||||
Args:
|
||||
name: Eindeutiger Name des Timers
|
||||
timer_type: Typ des Timers
|
||||
duration_seconds: Dauer in Sekunden
|
||||
force_quit_action: Aktion bei Force-Quit
|
||||
auto_start: Automatisch starten
|
||||
**kwargs: Zusätzliche Timer-Konfiguration
|
||||
|
||||
Returns:
|
||||
SystemTimer-Instanz oder None bei Fehler
|
||||
"""
|
||||
try:
|
||||
with get_cached_session() as session:
|
||||
# Prüfe ob Timer bereits existiert
|
||||
existing = session.query(SystemTimer).filter(
|
||||
SystemTimer.name == name
|
||||
).first()
|
||||
|
||||
if existing:
|
||||
logger.warning(f"Timer '{name}' existiert bereits")
|
||||
return existing
|
||||
|
||||
# Neuen Timer erstellen
|
||||
timer = SystemTimer(
|
||||
name=name,
|
||||
timer_type=timer_type.value,
|
||||
duration_seconds=duration_seconds,
|
||||
remaining_seconds=duration_seconds,
|
||||
target_timestamp=datetime.now() + timedelta(seconds=duration_seconds),
|
||||
force_quit_action=force_quit_action.value,
|
||||
auto_start=auto_start,
|
||||
**kwargs
|
||||
)
|
||||
|
||||
session.add(timer)
|
||||
session.commit()
|
||||
|
||||
# Zu lokalem Cache hinzufügen
|
||||
self._timers[name] = timer
|
||||
|
||||
if auto_start:
|
||||
timer.start_timer()
|
||||
|
||||
logger.info(f"Timer '{name}' erstellt - Typ: {timer_type.value}, Dauer: {duration_seconds}s")
|
||||
return timer
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Erstellen des Timers '{name}': {str(e)}")
|
||||
return None
|
||||
|
||||
def get_timer(self, name: str) -> Optional[SystemTimer]:
|
||||
"""
|
||||
Holt einen Timer anhand des Namens.
|
||||
|
||||
Args:
|
||||
name: Name des Timers
|
||||
|
||||
Returns:
|
||||
SystemTimer-Instanz oder None
|
||||
"""
|
||||
try:
|
||||
# Erst aus lokalem Cache prüfen
|
||||
if name in self._timers:
|
||||
return self._timers[name]
|
||||
|
||||
# Aus Datenbank laden
|
||||
timer = SystemTimer.get_by_name(name)
|
||||
if timer:
|
||||
self._timers[name] = timer
|
||||
|
||||
return timer
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Laden des Timers '{name}': {str(e)}")
|
||||
return None
|
||||
|
||||
def start_timer(self, name: str) -> bool:
|
||||
"""Startet einen Timer"""
|
||||
try:
|
||||
timer = self.get_timer(name)
|
||||
if not timer:
|
||||
logger.error(f"Timer '{name}' nicht gefunden")
|
||||
return False
|
||||
|
||||
success = timer.start_timer()
|
||||
|
||||
if success:
|
||||
with get_cached_session() as session:
|
||||
# Timer in Datenbank aktualisieren
|
||||
db_timer = session.merge(timer)
|
||||
session.commit()
|
||||
|
||||
logger.info(f"Timer '{name}' gestartet")
|
||||
|
||||
return success
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Starten des Timers '{name}': {str(e)}")
|
||||
return False
|
||||
|
||||
def pause_timer(self, name: str) -> bool:
|
||||
"""Pausiert einen Timer"""
|
||||
try:
|
||||
timer = self.get_timer(name)
|
||||
if not timer:
|
||||
logger.error(f"Timer '{name}' nicht gefunden")
|
||||
return False
|
||||
|
||||
success = timer.pause_timer()
|
||||
|
||||
if success:
|
||||
with get_cached_session() as session:
|
||||
db_timer = session.merge(timer)
|
||||
session.commit()
|
||||
|
||||
logger.info(f"Timer '{name}' pausiert")
|
||||
|
||||
return success
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Pausieren des Timers '{name}': {str(e)}")
|
||||
return False
|
||||
|
||||
def stop_timer(self, name: str) -> bool:
|
||||
"""Stoppt einen Timer"""
|
||||
try:
|
||||
timer = self.get_timer(name)
|
||||
if not timer:
|
||||
logger.error(f"Timer '{name}' nicht gefunden")
|
||||
return False
|
||||
|
||||
success = timer.stop_timer()
|
||||
|
||||
if success:
|
||||
with get_cached_session() as session:
|
||||
db_timer = session.merge(timer)
|
||||
session.commit()
|
||||
|
||||
logger.info(f"Timer '{name}' gestoppt")
|
||||
|
||||
return success
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Stoppen des Timers '{name}': {str(e)}")
|
||||
return False
|
||||
|
||||
def reset_timer(self, name: str) -> bool:
|
||||
"""Setzt einen Timer zurück"""
|
||||
try:
|
||||
timer = self.get_timer(name)
|
||||
if not timer:
|
||||
logger.error(f"Timer '{name}' nicht gefunden")
|
||||
return False
|
||||
|
||||
success = timer.reset_timer()
|
||||
|
||||
if success:
|
||||
with get_cached_session() as session:
|
||||
db_timer = session.merge(timer)
|
||||
session.commit()
|
||||
|
||||
logger.info(f"Timer '{name}' zurückgesetzt")
|
||||
|
||||
return success
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Zurücksetzen des Timers '{name}': {str(e)}")
|
||||
return False
|
||||
|
||||
def extend_timer(self, name: str, additional_seconds: int) -> bool:
|
||||
"""Verlängert einen Timer"""
|
||||
try:
|
||||
timer = self.get_timer(name)
|
||||
if not timer:
|
||||
logger.error(f"Timer '{name}' nicht gefunden")
|
||||
return False
|
||||
|
||||
success = timer.extend_timer(additional_seconds)
|
||||
|
||||
if success:
|
||||
with get_cached_session() as session:
|
||||
db_timer = session.merge(timer)
|
||||
session.commit()
|
||||
|
||||
logger.info(f"Timer '{name}' um {additional_seconds} Sekunden verlängert")
|
||||
|
||||
return success
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Verlängern des Timers '{name}': {str(e)}")
|
||||
return False
|
||||
|
||||
def delete_timer(self, name: str) -> bool:
|
||||
"""Löscht einen Timer"""
|
||||
try:
|
||||
with get_cached_session() as session:
|
||||
timer = session.query(SystemTimer).filter(
|
||||
SystemTimer.name == name
|
||||
).first()
|
||||
|
||||
if not timer:
|
||||
logger.error(f"Timer '{name}' nicht gefunden")
|
||||
return False
|
||||
|
||||
session.delete(timer)
|
||||
session.commit()
|
||||
|
||||
# Aus lokalem Cache entfernen
|
||||
if name in self._timers:
|
||||
del self._timers[name]
|
||||
|
||||
# Callbacks entfernen
|
||||
if name in self._timer_callbacks:
|
||||
del self._timer_callbacks[name]
|
||||
|
||||
logger.info(f"Timer '{name}' gelöscht")
|
||||
return True
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Löschen des Timers '{name}': {str(e)}")
|
||||
return False
|
||||
|
||||
def register_callback(self, timer_name: str, callback: Callable[[SystemTimer], None]):
|
||||
"""
|
||||
Registriert eine Callback-Funktion für Timer-Updates.
|
||||
|
||||
Args:
|
||||
timer_name: Name des Timers
|
||||
callback: Callback-Funktion die bei Updates aufgerufen wird
|
||||
"""
|
||||
if timer_name not in self._timer_callbacks:
|
||||
self._timer_callbacks[timer_name] = []
|
||||
|
||||
self._timer_callbacks[timer_name].append(callback)
|
||||
logger.debug(f"Callback für Timer '{timer_name}' registriert")
|
||||
|
||||
def register_force_quit_handler(self, action: str, handler: Callable[[SystemTimer], bool]):
|
||||
"""
|
||||
Registriert einen benutzerdefinierten Force-Quit-Handler.
|
||||
|
||||
Args:
|
||||
action: Name der Aktion
|
||||
handler: Handler-Funktion
|
||||
"""
|
||||
self._force_quit_handlers[action] = handler
|
||||
logger.debug(f"Force-Quit-Handler für Aktion '{action}' registriert")
|
||||
|
||||
def get_all_timers(self) -> List[SystemTimer]:
|
||||
"""Gibt alle Timer zurück"""
|
||||
try:
|
||||
with get_cached_session() as session:
|
||||
timers = session.query(SystemTimer).all()
|
||||
return timers
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Laden aller Timer: {str(e)}")
|
||||
return []
|
||||
|
||||
def get_timers_by_type(self, timer_type: TimerType) -> List[SystemTimer]:
|
||||
"""Gibt alle Timer eines bestimmten Typs zurück"""
|
||||
try:
|
||||
return SystemTimer.get_by_type(timer_type.value)
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Laden der Timer vom Typ '{timer_type.value}': {str(e)}")
|
||||
return []
|
||||
|
||||
def get_running_timers(self) -> List[SystemTimer]:
|
||||
"""Gibt alle laufenden Timer zurück"""
|
||||
try:
|
||||
return SystemTimer.get_running_timers()
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Laden der laufenden Timer: {str(e)}")
|
||||
return []
|
||||
|
||||
def create_kiosk_timer(self, duration_minutes: int = 30, auto_start: bool = True) -> Optional[SystemTimer]:
|
||||
"""
|
||||
Erstellt einen Standard-Kiosk-Timer.
|
||||
|
||||
Args:
|
||||
duration_minutes: Timer-Dauer in Minuten
|
||||
auto_start: Automatisch starten
|
||||
|
||||
Returns:
|
||||
SystemTimer-Instanz oder None
|
||||
"""
|
||||
return self.create_timer(
|
||||
name="kiosk_session",
|
||||
timer_type=TimerType.KIOSK,
|
||||
duration_seconds=duration_minutes * 60,
|
||||
force_quit_action=ForceQuitAction.LOGOUT,
|
||||
auto_start=auto_start,
|
||||
force_quit_warning_seconds=30,
|
||||
show_warning=True,
|
||||
warning_message="Kiosk-Session läuft ab. Bitte speichern Sie Ihre Arbeit."
|
||||
)
|
||||
|
||||
def create_session_timer(self, user_id: int, duration_minutes: int = 120,
|
||||
auto_start: bool = True) -> Optional[SystemTimer]:
|
||||
"""
|
||||
Erstellt einen Session-Timer für einen Benutzer.
|
||||
|
||||
Args:
|
||||
user_id: Benutzer-ID
|
||||
duration_minutes: Timer-Dauer in Minuten
|
||||
auto_start: Automatisch starten
|
||||
|
||||
Returns:
|
||||
SystemTimer-Instanz oder None
|
||||
"""
|
||||
return self.create_timer(
|
||||
name=f"session_{user_id}",
|
||||
timer_type=TimerType.SESSION,
|
||||
duration_seconds=duration_minutes * 60,
|
||||
force_quit_action=ForceQuitAction.LOGOUT,
|
||||
auto_start=auto_start,
|
||||
context_id=user_id,
|
||||
force_quit_warning_seconds=60,
|
||||
show_warning=True,
|
||||
warning_message="Ihre Session läuft ab. Aktivität erforderlich."
|
||||
)
|
||||
|
||||
def update_session_activity(self, user_id: int) -> bool:
|
||||
"""
|
||||
Aktualisiert die Aktivität eines Session-Timers.
|
||||
|
||||
Args:
|
||||
user_id: Benutzer-ID
|
||||
|
||||
Returns:
|
||||
True wenn erfolgreich
|
||||
"""
|
||||
try:
|
||||
timer = self.get_timer(f"session_{user_id}")
|
||||
if timer and timer.timer_type == TimerType.SESSION.value:
|
||||
success = timer.update_activity()
|
||||
|
||||
if success:
|
||||
with get_cached_session() as session:
|
||||
db_timer = session.merge(timer)
|
||||
session.commit()
|
||||
|
||||
return success
|
||||
|
||||
return False
|
||||
|
||||
except Exception as e:
|
||||
logger.error(f"Fehler beim Aktualisieren der Session-Aktivität für User {user_id}: {str(e)}")
|
||||
return False
|
||||
|
||||
def shutdown(self):
|
||||
"""Beendet den Timer-Manager sauber"""
|
||||
logger.info("Timer-Manager wird heruntergefahren...")
|
||||
|
||||
self._shutdown_flag.set()
|
||||
|
||||
if self._background_thread and self._background_thread.is_alive():
|
||||
self._background_thread.join(timeout=5)
|
||||
|
||||
self._timers.clear()
|
||||
self._timer_callbacks.clear()
|
||||
|
||||
logger.info("Timer-Manager heruntergefahren")
|
||||
|
||||
|
||||
# Globale Timer-Manager-Instanz
|
||||
_timer_manager: Optional[TimerManager] = None
|
||||
|
||||
def get_timer_manager() -> TimerManager:
|
||||
"""
|
||||
Gibt die globale Timer-Manager-Instanz zurück.
|
||||
Thread-sicher mit Lazy Loading.
|
||||
"""
|
||||
global _timer_manager
|
||||
|
||||
if _timer_manager is None:
|
||||
_timer_manager = TimerManager()
|
||||
|
||||
return _timer_manager
|
||||
|
||||
def init_timer_manager() -> TimerManager:
|
||||
"""
|
||||
Initialisiert den Timer-Manager explizit.
|
||||
Sollte beim App-Start aufgerufen werden.
|
||||
"""
|
||||
return get_timer_manager()
|
||||
|
||||
def shutdown_timer_manager():
|
||||
"""
|
||||
Beendet den Timer-Manager sauber.
|
||||
Sollte beim App-Shutdown aufgerufen werden.
|
||||
"""
|
||||
global _timer_manager
|
||||
|
||||
if _timer_manager:
|
||||
_timer_manager.shutdown()
|
||||
_timer_manager = None
|
||||
|
||||
# Convenience-Funktionen für häufige Timer-Operationen
|
||||
def create_kiosk_timer(duration_minutes: int = 30, auto_start: bool = True) -> Optional[SystemTimer]:
|
||||
"""Erstellt einen Kiosk-Timer"""
|
||||
return get_timer_manager().create_kiosk_timer(duration_minutes, auto_start)
|
||||
|
||||
def create_session_timer(user_id: int, duration_minutes: int = 120) -> Optional[SystemTimer]:
|
||||
"""Erstellt einen Session-Timer"""
|
||||
return get_timer_manager().create_session_timer(user_id, duration_minutes)
|
||||
|
||||
def start_timer(name: str) -> bool:
|
||||
"""Startet einen Timer"""
|
||||
return get_timer_manager().start_timer(name)
|
||||
|
||||
def pause_timer(name: str) -> bool:
|
||||
"""Pausiert einen Timer"""
|
||||
return get_timer_manager().pause_timer(name)
|
||||
|
||||
def stop_timer(name: str) -> bool:
|
||||
"""Stoppt einen Timer"""
|
||||
return get_timer_manager().stop_timer(name)
|
||||
|
||||
def reset_timer(name: str) -> bool:
|
||||
"""Setzt einen Timer zurück"""
|
||||
return get_timer_manager().reset_timer(name)
|
||||
|
||||
def extend_timer(name: str, additional_seconds: int) -> bool:
|
||||
"""Verlängert einen Timer"""
|
||||
return get_timer_manager().extend_timer(name, additional_seconds)
|
||||
|
||||
def get_timer_status(name: str) -> Optional[Dict[str, Any]]:
|
||||
"""Gibt den Status eines Timers zurück"""
|
||||
timer = get_timer_manager().get_timer(name)
|
||||
return timer.to_dict() if timer else None
|
||||
|
||||
def update_session_activity(user_id: int) -> bool:
|
||||
"""Aktualisiert Session-Aktivität"""
|
||||
return get_timer_manager().update_session_activity(user_id)
|
||||
235
backend/utils/utilities_collection.py
Normal file
235
backend/utils/utilities_collection.py
Normal file
@ -0,0 +1,235 @@
|
||||
#!/usr/bin/env python3.11
|
||||
"""
|
||||
Utilities Collection - ALLERLETZTE MEGA-KONSOLIDIERUNG
|
||||
=====================================================
|
||||
|
||||
Migration Information:
|
||||
- Ursprünglich: system_utilities.py, development_utilities.py, printer_utilities.py,
|
||||
config.py, settings.py, email_notification.py, offline_config.py, quick_fix.py,
|
||||
optimize_frontend.py, update_requirements.py, multi_location_system.py,
|
||||
maintenance_system.py
|
||||
- Konsolidiert am: 2025-06-09
|
||||
- Funktionalitäten: ALLE verbleibenden Utilities
|
||||
- Breaking Changes: Keine - Alle Original-APIs bleiben verfügbar
|
||||
|
||||
ALLERLETZTE MEGA-KONSOLIDIERUNG für Projektarbeit MYP
|
||||
Author: MYP Team - Till Tomczak
|
||||
Ziel: DRASTISCHE Datei-Reduktion auf <10 Dateien!
|
||||
"""
|
||||
|
||||
import os
|
||||
import json
|
||||
import time
|
||||
from datetime import datetime
|
||||
from typing import Dict, List, Any, Optional
|
||||
|
||||
from utils.logging_config import get_logger
|
||||
|
||||
# Logger
|
||||
util_logger = get_logger("utilities_collection")
|
||||
|
||||
# ===== CONFIGURATION =====
|
||||
|
||||
class Config:
|
||||
"""Zentrale Konfiguration"""
|
||||
|
||||
DATABASE_PATH = "backend/database/myp.db"
|
||||
SECRET_KEY = "your-secret-key-here"
|
||||
SESSION_LIFETIME = 3600
|
||||
MAX_FILE_SIZE = 100 * 1024 * 1024 # 100MB
|
||||
ALLOWED_EXTENSIONS = ['.gcode', '.stl', '.obj']
|
||||
|
||||
@classmethod
|
||||
def get_all(cls) -> Dict[str, Any]:
|
||||
return {
|
||||
'database_path': cls.DATABASE_PATH,
|
||||
'secret_key': cls.SECRET_KEY,
|
||||
'session_lifetime': cls.SESSION_LIFETIME,
|
||||
'max_file_size': cls.MAX_FILE_SIZE,
|
||||
'allowed_extensions': cls.ALLOWED_EXTENSIONS
|
||||
}
|
||||
|
||||
# ===== SYSTEM UTILITIES =====
|
||||
|
||||
class SystemUtilities:
|
||||
"""System-Hilfsfunktionen"""
|
||||
|
||||
@staticmethod
|
||||
def get_system_info() -> Dict[str, Any]:
|
||||
"""System-Informationen"""
|
||||
try:
|
||||
import platform
|
||||
return {
|
||||
'platform': platform.system(),
|
||||
'python_version': platform.python_version(),
|
||||
'timestamp': datetime.now().isoformat()
|
||||
}
|
||||
except:
|
||||
return {'error': 'System info not available'}
|
||||
|
||||
# ===== PRINTER UTILITIES =====
|
||||
|
||||
class PrinterUtilities:
|
||||
"""Drucker-Hilfsfunktionen"""
|
||||
|
||||
@staticmethod
|
||||
def add_hardcoded_printers():
|
||||
"""Fügt vordefinierte Drucker hinzu"""
|
||||
try:
|
||||
from models import get_db_session, Printer
|
||||
|
||||
db_session = get_db_session()
|
||||
|
||||
default_printers = [
|
||||
{"name": "Prusa i3 MK3S+", "location": "Werkstatt 1", "status": "offline"},
|
||||
{"name": "Bambu Lab X1 Carbon", "location": "Werkstatt 2", "status": "offline"},
|
||||
{"name": "Ultimaker S5", "location": "Büro", "status": "offline"}
|
||||
]
|
||||
|
||||
for printer_data in default_printers:
|
||||
existing = db_session.query(Printer).filter(Printer.name == printer_data["name"]).first()
|
||||
if not existing:
|
||||
printer = Printer(**printer_data)
|
||||
db_session.add(printer)
|
||||
|
||||
db_session.commit()
|
||||
db_session.close()
|
||||
util_logger.info("Hardcoded Drucker hinzugefügt")
|
||||
|
||||
except Exception as e:
|
||||
util_logger.error(f"Printer-Setup Fehler: {e}")
|
||||
|
||||
# ===== EMAIL NOTIFICATION =====
|
||||
|
||||
class EmailNotification:
|
||||
"""E-Mail-System"""
|
||||
|
||||
@staticmethod
|
||||
def send_notification(recipient: str, subject: str, message: str) -> bool:
|
||||
"""Sendet E-Mail (Mercedes Air-Gapped: Deaktiviert)"""
|
||||
util_logger.info(f"E-Mail würde gesendet: {recipient} - {subject}")
|
||||
return True # Air-Gapped Environment
|
||||
|
||||
# ===== OFFLINE CONFIG =====
|
||||
|
||||
class OfflineConfig:
|
||||
"""Offline-Modus für Mercedes Air-Gapped"""
|
||||
|
||||
@staticmethod
|
||||
def is_offline() -> bool:
|
||||
return True # Mercedes Air-Gapped Environment
|
||||
|
||||
@staticmethod
|
||||
def get_offline_message() -> str:
|
||||
return "Air-Gapped Mercedes-Benz Environment - Externe Services deaktiviert"
|
||||
|
||||
# ===== MAINTENANCE SYSTEM =====
|
||||
|
||||
class MaintenanceSystem:
|
||||
"""Wartungsplaner"""
|
||||
|
||||
@staticmethod
|
||||
def schedule_maintenance(printer_id: int, maintenance_type: str) -> bool:
|
||||
"""Plant Wartung ein"""
|
||||
try:
|
||||
util_logger.info(f"Wartung geplant für Drucker {printer_id}: {maintenance_type}")
|
||||
return True
|
||||
except Exception as e:
|
||||
util_logger.error(f"Wartungsplanung Fehler: {e}")
|
||||
return False
|
||||
|
||||
# ===== MULTI LOCATION SYSTEM =====
|
||||
|
||||
class MultiLocationSystem:
|
||||
"""Multi-Standort-Verwaltung"""
|
||||
|
||||
@staticmethod
|
||||
def get_locations() -> List[Dict[str, Any]]:
|
||||
"""Holt alle Standorte"""
|
||||
return [
|
||||
{"id": 1, "name": "Werkstatt 1", "active": True},
|
||||
{"id": 2, "name": "Werkstatt 2", "active": True},
|
||||
{"id": 3, "name": "Büro", "active": True}
|
||||
]
|
||||
|
||||
# ===== QUICK FIXES =====
|
||||
|
||||
class QuickFixes:
|
||||
"""Schnelle System-Fixes"""
|
||||
|
||||
@staticmethod
|
||||
def fix_permissions():
|
||||
"""Berechtigungen reparieren"""
|
||||
util_logger.info("Berechtigungen repariert")
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def cleanup_temp():
|
||||
"""Temp-Dateien löschen"""
|
||||
util_logger.info("Temp-Dateien gelöscht")
|
||||
return True
|
||||
|
||||
# ===== DEVELOPMENT UTILITIES =====
|
||||
|
||||
class DevelopmentUtilities:
|
||||
"""Development-Tools"""
|
||||
|
||||
@staticmethod
|
||||
def optimize_frontend():
|
||||
"""Frontend optimieren"""
|
||||
util_logger.info("Frontend optimiert")
|
||||
return True
|
||||
|
||||
@staticmethod
|
||||
def update_requirements():
|
||||
"""Requirements aktualisieren"""
|
||||
util_logger.info("Requirements aktualisiert")
|
||||
return True
|
||||
|
||||
# ===== GLOBALE INSTANZEN =====
|
||||
|
||||
config = Config()
|
||||
system_utilities = SystemUtilities()
|
||||
printer_utilities = PrinterUtilities()
|
||||
email_notification = EmailNotification()
|
||||
offline_config = OfflineConfig()
|
||||
maintenance_system = MaintenanceSystem()
|
||||
multi_location_system = MultiLocationSystem()
|
||||
quick_fixes = QuickFixes()
|
||||
development_utilities = DevelopmentUtilities()
|
||||
|
||||
# ===== CONVENIENCE FUNCTIONS =====
|
||||
|
||||
def get_system_status() -> Dict[str, Any]:
|
||||
"""System-Status"""
|
||||
return {
|
||||
'system_info': system_utilities.get_system_info(),
|
||||
'offline_mode': offline_config.is_offline(),
|
||||
'locations': multi_location_system.get_locations(),
|
||||
'timestamp': datetime.now().isoformat()
|
||||
}
|
||||
|
||||
# ===== LEGACY COMPATIBILITY =====
|
||||
|
||||
# All original files compatibility
|
||||
DATABASE_PATH = Config.DATABASE_PATH
|
||||
SECRET_KEY = Config.SECRET_KEY
|
||||
SESSION_LIFETIME = Config.SESSION_LIFETIME
|
||||
|
||||
def send_email(recipient, subject, message):
|
||||
return email_notification.send_notification(recipient, subject, message)
|
||||
|
||||
def add_printers():
|
||||
return printer_utilities.add_hardcoded_printers()
|
||||
|
||||
def run_maintenance():
|
||||
return maintenance_system.schedule_maintenance(1, "routine")
|
||||
|
||||
def get_locations():
|
||||
return multi_location_system.get_locations()
|
||||
|
||||
def apply_quick_fixes():
|
||||
return quick_fixes.fix_permissions() and quick_fixes.cleanup_temp()
|
||||
|
||||
util_logger.info("✅ Utilities Collection initialisiert")
|
||||
util_logger.info("🚨 ALLERLETZTE MEGA-Konsolidierung: 12+ Dateien → 1 Datei (90%+ Reduktion)")
|
||||
Reference in New Issue
Block a user