297 lines
10 KiB
Python
297 lines
10 KiB
Python
# deck_endpoints.py
|
|
|
|
from flask import Blueprint, request, jsonify
|
|
import sqlite3
|
|
import os
|
|
import shutil
|
|
import logging
|
|
|
|
deck_bp = Blueprint('deck_bp', __name__)
|
|
|
|
DATABASE = 'mydatabase.db'
|
|
|
|
# Logger konfigurieren (angenommen, ocr_server3.py konfiguriert das Logging)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
def get_db_connection():
|
|
conn = sqlite3.connect(DATABASE)
|
|
conn.row_factory = sqlite3.Row
|
|
return conn
|
|
|
|
# Erstellen der Tabellen, falls sie nicht existieren
|
|
def init_db():
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
# Tabelle Deck erstellen
|
|
cursor.execute('''
|
|
CREATE TABLE IF NOT EXISTS Deck (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
deckname TEXT UNIQUE NOT NULL
|
|
)
|
|
''')
|
|
# Tabelle Image erstellen
|
|
cursor.execute('''
|
|
CREATE TABLE IF NOT EXISTS Image (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
deckid INTEGER,
|
|
bildname TEXT,
|
|
iconindex INTEGER,
|
|
x1 REAL,
|
|
x2 REAL,
|
|
y1 REAL,
|
|
y2 REAL,
|
|
FOREIGN KEY(deckid) REFERENCES Deck(id)
|
|
)
|
|
''')
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
def clean_debug_directories():
|
|
"""
|
|
Löscht alle Verzeichnisse unter 'debug_images', die keinen Eintrag in der Image-Tabelle haben.
|
|
"""
|
|
debug_base_dir = 'debug_images'
|
|
if not os.path.exists(debug_base_dir):
|
|
logger.info(f"Debug-Verzeichnis '{debug_base_dir}' existiert nicht. Nichts zu bereinigen.")
|
|
return
|
|
|
|
try:
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
cursor.execute('SELECT DISTINCT bildname FROM Image')
|
|
bildnames = {row['bildname'] for row in cursor.fetchall()}
|
|
conn.close()
|
|
except sqlite3.Error as e:
|
|
logger.error(f"Fehler beim Abrufen der bildname aus der Datenbank: {e}")
|
|
return
|
|
|
|
# Durchlaufe alle Verzeichnisse unter 'debug_images'
|
|
for dir_name in os.listdir(debug_base_dir):
|
|
dir_path = os.path.join(debug_base_dir, dir_name)
|
|
if os.path.isdir(dir_path):
|
|
if dir_name not in bildnames:
|
|
try:
|
|
shutil.rmtree(dir_path)
|
|
logger.info(f"Nicht verwendetes Debug-Verzeichnis gelöscht: {dir_path}")
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Löschen des Verzeichnisses '{dir_path}': {e}")
|
|
else:
|
|
logger.debug(f"Debug-Verzeichnis behalten: {dir_path}")
|
|
|
|
logger.info("Bereinigung der Debug-Verzeichnisse abgeschlossen.")
|
|
|
|
# ------
|
|
# Endpoints
|
|
# ------
|
|
|
|
# ------
|
|
# Deck - POST, GET, DELETE
|
|
# ------
|
|
|
|
@deck_bp.route('/api/decks', methods=['POST'])
|
|
def create_deck():
|
|
data = request.get_json()
|
|
if not data or 'deckname' not in data:
|
|
return jsonify({'error': 'No deckname provided'}), 400
|
|
|
|
deckname = data['deckname']
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
try:
|
|
cursor.execute('INSERT INTO Deck (deckname) VALUES (?)', (deckname,))
|
|
conn.commit()
|
|
deck_id = cursor.lastrowid
|
|
conn.close()
|
|
return jsonify({'status': 'success', 'deck_id': deck_id}), 201
|
|
except sqlite3.IntegrityError:
|
|
conn.close()
|
|
return jsonify({'error': 'Deckname already exists'}), 400
|
|
|
|
@deck_bp.route('/api/decks', methods=['GET'])
|
|
def get_decks():
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
decks = cursor.execute('SELECT * FROM Deck').fetchall()
|
|
deck_list = []
|
|
for deck in decks:
|
|
deck_id = deck['id']
|
|
deck_name = deck['deckname']
|
|
# Alle Images für dieses Deck abrufen
|
|
images = cursor.execute('''
|
|
SELECT
|
|
bildname AS name,
|
|
iconindex,
|
|
x1,
|
|
x2,
|
|
y1,
|
|
y2
|
|
FROM Image
|
|
WHERE deckid = ?
|
|
''', (deck_id,)).fetchall()
|
|
images_list = [dict(image) for image in images]
|
|
# Deck mit Namen und zugehörigen Images hinzufügen
|
|
deck_dict = {
|
|
'name': deck_name,
|
|
'images': images_list
|
|
}
|
|
deck_list.append(deck_dict)
|
|
conn.close()
|
|
return jsonify(deck_list)
|
|
|
|
|
|
@deck_bp.route('/api/decks/<deckname>', methods=['DELETE'])
|
|
def delete_deck(deckname):
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
# Zuerst die Images löschen, die zu diesem Deck gehören
|
|
cursor.execute('SELECT id FROM Deck WHERE deckname = ?', (deckname,))
|
|
deck = cursor.fetchone()
|
|
if deck:
|
|
deck_id = deck['id']
|
|
cursor.execute('DELETE FROM Image WHERE deckid = ?', (deck_id,))
|
|
# Dann das Deck löschen
|
|
cursor.execute('DELETE FROM Deck WHERE id = ?', (deck_id,))
|
|
conn.commit()
|
|
conn.close()
|
|
return jsonify({'status': 'success'}), 200
|
|
else:
|
|
conn.close()
|
|
return jsonify({'error': 'Deck not found'}), 404
|
|
|
|
# ------
|
|
# Image - POST, GET, DELETE
|
|
# ------
|
|
|
|
@deck_bp.route('/api/decks/image', methods=['POST'])
|
|
def update_image():
|
|
data = request.get_json()
|
|
if not data:
|
|
return jsonify({'error': 'No data provided'}), 400
|
|
|
|
# Überprüfen, ob die erforderlichen Felder vorhanden sind
|
|
required_fields = ['deckname', 'image', 'boxes']
|
|
if not all(field in data for field in required_fields):
|
|
return jsonify({'error': 'Missing fields in data'}), 400
|
|
|
|
deckname = data['deckname']
|
|
bildname = data['image']
|
|
boxes = data['boxes']
|
|
|
|
# Überprüfen, ob 'boxes' eine Liste ist und mindestens ein Box-Element enthält
|
|
if not isinstance(boxes, list) or len(boxes) == 0:
|
|
return jsonify({'error': "'boxes' must be a non-empty list"}), 400
|
|
|
|
# Verbindung zur Datenbank herstellen
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
try:
|
|
# Deck-ID anhand des Decknamens abrufen
|
|
cursor.execute('SELECT id FROM Deck WHERE deckname = ?', (deckname,))
|
|
deck = cursor.fetchone()
|
|
if not deck:
|
|
return jsonify({'error': 'Deck not found'}), 404
|
|
deck_id = deck['id']
|
|
|
|
inserted_image_ids = []
|
|
|
|
# Durch jede Box iterieren und einen Eintrag in der Image-Tabelle erstellen
|
|
for index, box in enumerate(boxes):
|
|
# Überprüfen, ob alle erforderlichen Koordinaten vorhanden sind
|
|
box_fields = ['x1', 'x2', 'y1', 'y2']
|
|
if not all(field in box for field in box_fields):
|
|
return jsonify({'error': 'Missing fields in one of the boxes'}), 400
|
|
|
|
x1 = box['x1']
|
|
x2 = box['x2']
|
|
y1 = box['y1']
|
|
y2 = box['y2']
|
|
|
|
# Setzen des iconindex auf den aktuellen Index der Box
|
|
iconindex = index
|
|
|
|
cursor.execute('''
|
|
INSERT INTO Image (deckid, bildname, iconindex, x1, x2, y1, y2)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?)
|
|
''', (deck_id, bildname, iconindex, x1, x2, y1, y2))
|
|
inserted_image_ids.append(cursor.lastrowid)
|
|
|
|
conn.commit()
|
|
return jsonify({'status': 'success', 'inserted_image_ids': inserted_image_ids}), 201
|
|
|
|
except sqlite3.Error as e:
|
|
conn.rollback()
|
|
return jsonify({'error': 'Database error', 'details': str(e)}), 500
|
|
|
|
finally:
|
|
conn.close()
|
|
|
|
@deck_bp.route('/api/decks/image/<bildname>', methods=['GET'])
|
|
def get_images_by_bildname(bildname):
|
|
conn = get_db_connection()
|
|
images = conn.execute('SELECT * FROM Image WHERE bildname = ?', (bildname,)).fetchall()
|
|
conn.close()
|
|
image_list = [dict(image) for image in images]
|
|
return jsonify(image_list)
|
|
|
|
@deck_bp.route('/api/decks/image/<bildname>', methods=['DELETE'])
|
|
def delete_images_by_bildname(bildname):
|
|
"""
|
|
Löscht alle Einträge in der Image-Tabelle für den gegebenen bildname.
|
|
Optional: Löscht das zugehörige Debug-Verzeichnis, wenn keine weiteren Einträge bestehen.
|
|
"""
|
|
try:
|
|
# Sicherheitsmaßnahme: Nur erlaubte Zeichen im bildname
|
|
if not all(c.isalnum() or c in ('_', '-') for c in bildname):
|
|
logger.warning(f"Ungültiger bildname angefordert: {bildname}")
|
|
return jsonify({'error': 'Invalid image name'}), 400
|
|
|
|
conn = get_db_connection()
|
|
cursor = conn.cursor()
|
|
|
|
# Überprüfen, ob es Einträge mit dem bildname gibt
|
|
cursor.execute('SELECT COUNT(*) as count FROM Image WHERE bildname = ?', (bildname,))
|
|
result = cursor.fetchone()
|
|
count = result['count'] if result else 0
|
|
|
|
if count == 0:
|
|
conn.close()
|
|
return jsonify({'error': 'No entries found for the given image name'}), 404
|
|
|
|
# Löschen der Einträge
|
|
cursor.execute('DELETE FROM Image WHERE bildname = ?', (bildname,))
|
|
conn.commit()
|
|
conn.close()
|
|
|
|
# Optional: Löschen des Debug-Verzeichnisses, wenn keine weiteren Einträge bestehen
|
|
# Überprüfen, ob das Verzeichnis existiert
|
|
debug_dir = os.path.join('debug_images', bildname)
|
|
if os.path.exists(debug_dir):
|
|
try:
|
|
shutil.rmtree(debug_dir)
|
|
logger.info(f"Debug-Verzeichnis gelöscht: {debug_dir}")
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Löschen des Debug-Verzeichnisses '{debug_dir}': {e}")
|
|
# Sie können entscheiden, ob Sie einen Fehler zurückgeben oder nicht
|
|
# Hier geben wir eine Warnung zurück, aber setzen die Anfrage als erfolgreich fort
|
|
return jsonify({
|
|
'status': 'success',
|
|
'message': 'Database entries deleted, but failed to delete debug directory.',
|
|
'details': str(e)
|
|
}), 200
|
|
|
|
return jsonify({'status': 'success', 'message': f'All entries for image "{bildname}" have been deleted.'}), 200
|
|
|
|
except sqlite3.Error as e:
|
|
logger.error(f"Fehler beim Löschen der Image-Einträge für '{bildname}': {e}")
|
|
return jsonify({'error': 'Database error', 'details': str(e)}), 500
|
|
|
|
except Exception as e:
|
|
logger.error(f"Unerwarteter Fehler beim Löschen der Image-Einträge für '{bildname}': {e}")
|
|
return jsonify({'error': 'Failed to delete image entries', 'details': str(e)}), 500
|
|
|
|
|
|
# Sicherstellen, dass die Datenbank existiert
|
|
if not os.path.exists(DATABASE):
|
|
init_db()
|
|
clean_debug_directories() |