477 lines
19 KiB
Python
477 lines
19 KiB
Python
from flask import Flask, render_template, request, jsonify, url_for, redirect, session
|
|
import pandas as pd
|
|
import os
|
|
import logging
|
|
import numpy as np
|
|
from datetime import datetime, timedelta
|
|
from dotenv import load_dotenv
|
|
import sqlite3
|
|
from functools import wraps
|
|
from contextlib import contextmanager
|
|
import time
|
|
import threading
|
|
import markdown2
|
|
|
|
app = Flask(__name__, static_folder='static')
|
|
app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'dev')
|
|
app.config['ALLOWED_IP_RANGES'] = os.getenv('ALLOWED_IP_RANGES', '192.168.0.0/16,10.0.0.0/8').split(',')
|
|
app.config['VERSION'] = '1.2.19'
|
|
app.config['DATABASE'] = 'data/customers.db'
|
|
app.config['DATABASE_TIMEOUT'] = 20
|
|
app.config['DATABASE_POOL_SIZE'] = 5
|
|
|
|
logging.basicConfig(level=logging.INFO)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
# Thread-lokaler Speicher für Datenbankverbindungen
|
|
thread_local = threading.local()
|
|
|
|
def get_db_connection():
|
|
"""Erstellt eine neue Datenbankverbindung für den aktuellen Thread"""
|
|
if not hasattr(thread_local, "connection"):
|
|
thread_local.connection = sqlite3.connect(app.config['DATABASE'], timeout=app.config['DATABASE_TIMEOUT'])
|
|
thread_local.connection.row_factory = sqlite3.Row
|
|
return thread_local.connection
|
|
|
|
@contextmanager
|
|
def get_db():
|
|
"""Context Manager für Datenbankverbindungen"""
|
|
conn = get_db_connection()
|
|
try:
|
|
yield conn
|
|
except Exception:
|
|
conn.rollback()
|
|
raise
|
|
finally:
|
|
conn.commit()
|
|
|
|
def init_db():
|
|
"""Initialisiert die SQLite-Datenbank mit der notwendigen Tabelle."""
|
|
with get_db() as conn:
|
|
c = conn.cursor()
|
|
|
|
try:
|
|
# Erstelle die Kunden-Tabelle
|
|
c.execute('''
|
|
CREATE TABLE IF NOT EXISTS customers (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
nummer TEXT,
|
|
name TEXT,
|
|
strasse TEXT,
|
|
plz TEXT,
|
|
ort TEXT,
|
|
telefon TEXT,
|
|
mobil TEXT,
|
|
email TEXT,
|
|
bemerkung TEXT,
|
|
fachrichtung TEXT,
|
|
tag TEXT,
|
|
handy TEXT,
|
|
tele_firma TEXT,
|
|
kontakt1 TEXT,
|
|
kontakt2 TEXT,
|
|
kontakt3 TEXT
|
|
)
|
|
''')
|
|
|
|
# Optimierte Indizes für die häufigsten Suchanfragen
|
|
c.execute('CREATE INDEX IF NOT EXISTS idx_customers_name_ort ON customers(name, ort)')
|
|
c.execute('CREATE INDEX IF NOT EXISTS idx_customers_fachrichtung ON customers(fachrichtung)')
|
|
c.execute('CREATE INDEX IF NOT EXISTS idx_customers_tag ON customers(tag)')
|
|
c.execute('CREATE INDEX IF NOT EXISTS idx_customers_plz ON customers(plz)')
|
|
|
|
# Zusammengesetzter Index für die häufigste Suchkombination
|
|
c.execute('CREATE INDEX IF NOT EXISTS idx_customers_search ON customers(name, ort, fachrichtung, tag)')
|
|
|
|
logger.info('Datenbank initialisiert')
|
|
except Exception as e:
|
|
logger.error(f'Fehler bei der Datenbankinitialisierung: {str(e)}')
|
|
raise
|
|
|
|
def isIPInSubnet(ip, subnet):
|
|
"""Überprüft, ob eine IP-Adresse in einem Subnetz liegt."""
|
|
try:
|
|
# Teile die IP und das Subnetz in ihre Komponenten
|
|
subnet_ip, bits = subnet.split('/')
|
|
ip_parts = [int(x) for x in ip.split('.')]
|
|
subnet_parts = [int(x) for x in subnet_ip.split('.')]
|
|
|
|
# Konvertiere IPs in 32-bit Zahlen
|
|
ip_num = (ip_parts[0] << 24) | (ip_parts[1] << 16) | (ip_parts[2] << 8) | ip_parts[3]
|
|
subnet_num = (subnet_parts[0] << 24) | (subnet_parts[1] << 16) | (subnet_parts[2] << 8) | subnet_parts[3]
|
|
|
|
# Erstelle die Subnetzmaske
|
|
mask = ~((1 << (32 - int(bits))) - 1)
|
|
|
|
# Prüfe, ob die IP im Subnetz liegt
|
|
return (ip_num & mask) == (subnet_num & mask)
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei der IP-Überprüfung: {str(e)}")
|
|
return False
|
|
|
|
def import_csv():
|
|
"""Importiert die CSV-Datei in die Datenbank"""
|
|
try:
|
|
with get_db() as conn:
|
|
c = conn.cursor()
|
|
|
|
# Lösche bestehende Daten
|
|
c.execute('DELETE FROM customers')
|
|
|
|
# Importiere MEDISOFT-Daten
|
|
if os.path.exists('data/customers.csv'):
|
|
logger.info("Importiere MEDISOFT-Daten...")
|
|
df = pd.read_csv('data/customers.csv', encoding='iso-8859-1')
|
|
df.columns = df.columns.str.strip().str.replace('"', '')
|
|
df = df.apply(lambda x: x.str.strip().str.replace('"', '') if x.dtype == "object" else x)
|
|
|
|
# Filtere Datensätze mit Fachrichtung "intern"
|
|
df = df[df['Fachrichtung'].str.lower() != 'intern']
|
|
|
|
# Bereite die Daten für den Batch-Insert vor
|
|
data = [(
|
|
row['VorNachname'], row['Nummer'], row['Strasse'], row['PLZ'], row['Ort'],
|
|
row['Tel'], row['Tel'], row['mail'], row['Fachrichtung'], 'medisoft',
|
|
row['Handy'], row['Tele Firma'], row['Kontakt1'], row['Kontakt2'], row['Kontakt3']
|
|
) for _, row in df.iterrows()]
|
|
|
|
# Führe Batch-Insert durch
|
|
c.executemany('''
|
|
INSERT INTO customers (
|
|
name, nummer, strasse, plz, ort, telefon, mobil, email,
|
|
fachrichtung, tag, handy, tele_firma, kontakt1, kontakt2, kontakt3
|
|
)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
''', data)
|
|
else:
|
|
logger.warning("MEDISOFT CSV-Datei nicht gefunden")
|
|
|
|
# Importiere MEDICONSULT-Daten
|
|
if os.path.exists('data/customers_snk.csv'):
|
|
logger.info("Importiere MEDICONSULT-Daten...")
|
|
df_snk = pd.read_csv('data/customers_snk.csv', encoding='iso-8859-1')
|
|
df_snk.columns = df_snk.columns.str.strip().str.replace('"', '')
|
|
df_snk = df_snk.apply(lambda x: x.str.strip().str.replace('"', '') if x.dtype == "object" else x)
|
|
|
|
# Filtere Datensätze mit Fachrichtung "intern"
|
|
df_snk = df_snk[df_snk['Fachrichtung'].str.lower() != 'intern']
|
|
|
|
# Bereite die Daten für den Batch-Insert vor
|
|
data = [(
|
|
row['VorNachname'], row['Nummer'], row['Strasse'], row['PLZ'], row['Ort'],
|
|
row['Tel'], row['Tel'], row['mail'], row['Fachrichtung'], 'mediconsult',
|
|
row['Handy'], row['Tele Firma'], row['Kontakt1'], row['Kontakt2'], row['Kontakt3']
|
|
) for _, row in df_snk.iterrows()]
|
|
|
|
# Führe Batch-Insert durch
|
|
c.executemany('''
|
|
INSERT INTO customers (
|
|
name, nummer, strasse, plz, ort, telefon, mobil, email,
|
|
fachrichtung, tag, handy, tele_firma, kontakt1, kontakt2, kontakt3
|
|
)
|
|
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
|
|
''', data)
|
|
else:
|
|
logger.warning("MEDICONSULT CSV-Datei nicht gefunden")
|
|
|
|
logger.info("CSV-Daten erfolgreich in die Datenbank importiert")
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Importieren der CSV-Datei: {str(e)}")
|
|
raise
|
|
|
|
@app.route('/login', methods=['GET', 'POST'])
|
|
def login():
|
|
# Überprüfe, ob die Client-IP in einem der erlaubten Bereiche liegt
|
|
client_ip = request.headers.get('X-Forwarded-For', request.remote_addr)
|
|
|
|
# Überprüfe, ob die Client-IP in einem der erlaubten Bereichen liegt
|
|
is_allowed = any(isIPInSubnet(client_ip, range.strip()) for range in app.config['ALLOWED_IP_RANGES'] if range.strip())
|
|
|
|
if is_allowed:
|
|
logger.info(f"Client-IP {client_ip} ist in einem erlaubten Bereich, automatischer Login")
|
|
session['logged_in'] = True
|
|
return redirect(url_for('index'))
|
|
|
|
if request.method == 'POST':
|
|
password = request.form.get('password')
|
|
if password == os.environ.get('LOGIN_PASSWORD'):
|
|
session['logged_in'] = True
|
|
logger.info("Erfolgreicher Login")
|
|
return redirect(url_for('index'))
|
|
else:
|
|
logger.warning("Falsches Passwort eingegeben")
|
|
return render_template('login.html', error="Falsches Passwort")
|
|
|
|
logger.info("Zeige Login-Seite")
|
|
return render_template('login.html')
|
|
|
|
@app.route('/')
|
|
def index():
|
|
logger.info(f"Index-Route aufgerufen. Session Status: {session}")
|
|
if not session.get('logged_in'):
|
|
logger.info("Benutzer nicht eingeloggt, Weiterleitung zum Login")
|
|
return redirect(url_for('login'))
|
|
|
|
client_ip = request.headers.get('X-Forwarded-For', request.remote_addr)
|
|
logger.info(f"Client-IP: {client_ip}")
|
|
logger.info(f"Erlaubte IP-Bereiche: {app.config['ALLOWED_IP_RANGES']}")
|
|
return render_template('index.html', allowed_ip_ranges=','.join(app.config['ALLOWED_IP_RANGES']), version=app.config['VERSION'])
|
|
|
|
@app.route('/search', methods=['GET', 'POST'])
|
|
def search():
|
|
if not session.get('logged_in'):
|
|
return jsonify({'error': 'Nicht eingeloggt'}), 401
|
|
|
|
try:
|
|
if request.method == 'POST':
|
|
data = request.get_json()
|
|
search_query = data.get('query', '')
|
|
tag = data.get('tag', 'medisoft')
|
|
else:
|
|
search_query = request.args.get('q', '')
|
|
name = request.args.get('name', '')
|
|
ort = request.args.get('ort', '')
|
|
nummer = request.args.get('nummer', '')
|
|
plz = request.args.get('plz', '')
|
|
fachrichtung = request.args.get('fachrichtung', '')
|
|
tag = request.args.get('tag', 'medisoft')
|
|
|
|
with get_db() as conn:
|
|
c = conn.cursor()
|
|
|
|
# Baue die SQL-Abfrage
|
|
sql_query = '''
|
|
SELECT
|
|
nummer,
|
|
name,
|
|
strasse,
|
|
plz,
|
|
ort,
|
|
telefon,
|
|
mobil,
|
|
email,
|
|
fachrichtung,
|
|
tag,
|
|
handy,
|
|
tele_firma,
|
|
kontakt1,
|
|
kontakt2,
|
|
kontakt3
|
|
FROM customers
|
|
WHERE 1=1
|
|
'''
|
|
params = []
|
|
|
|
# Füge die Suchbedingungen hinzu
|
|
if search_query:
|
|
# Optimierte Suche mit FTS (Full Text Search)
|
|
sql_query += """
|
|
AND (
|
|
name LIKE ? OR
|
|
nummer LIKE ? OR
|
|
fachrichtung LIKE ? OR
|
|
ort LIKE ? OR
|
|
plz LIKE ? OR
|
|
strasse LIKE ? OR
|
|
telefon LIKE ? OR
|
|
mobil LIKE ? OR
|
|
email LIKE ? OR
|
|
bemerkung LIKE ? OR
|
|
tag LIKE ? OR
|
|
handy LIKE ? OR
|
|
tele_firma LIKE ? OR
|
|
kontakt1 LIKE ? OR
|
|
kontakt2 LIKE ? OR
|
|
kontakt3 LIKE ?
|
|
)
|
|
"""
|
|
search_term = f"%{search_query}%"
|
|
params.extend([search_term] * 16) # 16 Felder für die allgemeine Suche
|
|
|
|
if name:
|
|
sql_query += " AND name LIKE ?"
|
|
params.append(f"%{name}%")
|
|
|
|
if ort:
|
|
sql_query += " AND ort LIKE ?"
|
|
params.append(f"%{ort}%")
|
|
|
|
if nummer:
|
|
sql_query += " AND nummer LIKE ?"
|
|
params.append(f"%{nummer}%")
|
|
|
|
if plz:
|
|
sql_query += " AND plz LIKE ?"
|
|
params.append(f"%{plz}%")
|
|
|
|
if fachrichtung:
|
|
sql_query += " AND fachrichtung LIKE ?"
|
|
params.append(f"%{fachrichtung}%")
|
|
|
|
# Filter nach Tag
|
|
if tag != 'all':
|
|
sql_query += " AND tag = ?"
|
|
params.append(tag)
|
|
|
|
# Füge LIMIT hinzu und optimiere die Sortierung
|
|
sql_query += " ORDER BY name LIMIT 100"
|
|
|
|
# Führe die Abfrage aus
|
|
c.execute(sql_query, params)
|
|
results = c.fetchall()
|
|
|
|
formatted_results = []
|
|
for row in results:
|
|
customer = {
|
|
'nummer': row[0],
|
|
'name': row[1],
|
|
'strasse': row[2],
|
|
'plz': row[3],
|
|
'ort': row[4],
|
|
'telefon': row[5],
|
|
'mobil': row[6],
|
|
'email': row[7],
|
|
'fachrichtung': row[8],
|
|
'tag': row[9],
|
|
'handy': row[10],
|
|
'tele_firma': row[11],
|
|
'kontakt1': row[12],
|
|
'kontakt2': row[13],
|
|
'kontakt3': row[14]
|
|
}
|
|
formatted_results.append(customer)
|
|
|
|
return jsonify(formatted_results)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei der Suche: {str(e)}")
|
|
return jsonify({'error': str(e)}), 500
|
|
|
|
@app.route('/api/fachrichtungen')
|
|
def get_fachrichtungen():
|
|
try:
|
|
search_term = request.args.get('q', '').lower()
|
|
with get_db() as conn:
|
|
c = conn.cursor()
|
|
|
|
# Hole alle eindeutigen Fachrichtungen, die mit dem Suchbegriff übereinstimmen
|
|
c.execute('''
|
|
SELECT DISTINCT fachrichtung
|
|
FROM customers
|
|
WHERE fachrichtung IS NOT NULL
|
|
AND fachrichtung != ''
|
|
AND LOWER(fachrichtung) LIKE ?
|
|
ORDER BY fachrichtung
|
|
LIMIT 10
|
|
''', (f'%{search_term}%',))
|
|
|
|
fachrichtungen = [row[0] for row in c.fetchall()]
|
|
return jsonify(fachrichtungen)
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Abrufen der Fachrichtungen: {str(e)}")
|
|
return jsonify([])
|
|
|
|
@app.route('/api/orte')
|
|
def get_orte():
|
|
try:
|
|
search_term = request.args.get('q', '').lower()
|
|
with get_db() as conn:
|
|
c = conn.cursor()
|
|
|
|
# Hole alle eindeutigen Orte, die mit dem Suchbegriff übereinstimmen
|
|
c.execute('''
|
|
SELECT DISTINCT ort
|
|
FROM customers
|
|
WHERE ort IS NOT NULL
|
|
AND ort != ''
|
|
AND LOWER(ort) LIKE ?
|
|
ORDER BY ort
|
|
LIMIT 10
|
|
''', (f'%{search_term}%',))
|
|
|
|
orte = [row[0] for row in c.fetchall()]
|
|
return jsonify(orte)
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Abrufen der Orte: {str(e)}")
|
|
return jsonify([])
|
|
|
|
@app.route('/upload', methods=['GET', 'POST'])
|
|
def upload():
|
|
if not session.get('logged_in'):
|
|
return redirect(url_for('login'))
|
|
|
|
if request.method == 'POST':
|
|
if request.form.get('password') != os.environ.get('UPLOAD_PASSWORD'):
|
|
return render_template('upload.html', error="Falsches Passwort", version=app.config['VERSION'])
|
|
|
|
if 'customers_snk' not in request.files or 'customers' not in request.files:
|
|
return render_template('upload.html', error="Bitte beide CSV-Dateien auswählen", version=app.config['VERSION'])
|
|
|
|
customers_snk = request.files['customers_snk']
|
|
customers = request.files['customers']
|
|
|
|
if customers_snk.filename == '' or customers.filename == '':
|
|
return render_template('upload.html', error="Keine Datei ausgewählt", version=app.config['VERSION'])
|
|
|
|
if not customers_snk.filename.endswith('.csv') or not customers.filename.endswith('.csv'):
|
|
return render_template('upload.html', error="Nur CSV-Dateien sind erlaubt", version=app.config['VERSION'])
|
|
|
|
try:
|
|
# Speichere die Dateien
|
|
customers_snk.save('data/customers_snk.csv')
|
|
customers.save('data/customers.csv')
|
|
|
|
# Importiere die Daten in die Datenbank
|
|
import_csv('data/customers_snk.csv', 'snk')
|
|
import_csv('data/customers.csv', 'medisoft')
|
|
|
|
return render_template('upload.html', success="Dateien erfolgreich hochgeladen und importiert", version=app.config['VERSION'])
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Upload: {str(e)}")
|
|
return render_template('upload.html', error=f"Fehler beim Upload: {str(e)}", version=app.config['VERSION'])
|
|
|
|
return render_template('upload.html', version=app.config['VERSION'])
|
|
|
|
@app.route('/readme')
|
|
def readme():
|
|
if not session.get('logged_in'):
|
|
return redirect(url_for('login'))
|
|
|
|
try:
|
|
with open('README.md', 'r', encoding='utf-8') as f:
|
|
content = f.read()
|
|
html_content = markdown2.markdown(content, extras=['fenced-code-blocks', 'tables'])
|
|
return render_template('readme.html', content=html_content, version=app.config['VERSION'])
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Lesen der README: {str(e)}")
|
|
return render_template('readme.html', error="Fehler beim Lesen der README", version=app.config['VERSION'])
|
|
|
|
def init_app(app):
|
|
"""Initialisiert die Anwendung mit allen notwendigen Einstellungen."""
|
|
with app.app_context():
|
|
try:
|
|
# Stelle sicher, dass der data-Ordner existiert
|
|
os.makedirs('data', exist_ok=True)
|
|
|
|
# Lösche die alte Datenbank, falls sie existiert
|
|
if os.path.exists(app.config['DATABASE']):
|
|
try:
|
|
os.remove(app.config['DATABASE'])
|
|
logger.info(f"Alte Datenbank {app.config['DATABASE']} wurde gelöscht")
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Löschen der alten Datenbank: {str(e)}")
|
|
|
|
# Initialisiere die Datenbank
|
|
init_db()
|
|
# Importiere die CSV-Daten
|
|
import_csv()
|
|
logger.info("Anwendung erfolgreich initialisiert")
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei der Initialisierung: {str(e)}")
|
|
raise
|
|
|
|
# Initialisiere die App
|
|
init_app(app)
|
|
|
|
if __name__ == '__main__':
|
|
app.run(debug=True, port=5001) |