#!/usr/bin/env python3
"""
HVAC ADMIN - Professionele Document Sorteerder
Ondersteunt GUI, CLI en automatische dagelijkse scans.
Werkt met trefwoorden en optioneel AI (transformers).
"""

import os
import sys
import argparse
import shutil
import re
import json
import time
import threading
import configparser
import logging
from pathlib import Path
from datetime import datetime
from collections import defaultdict
from typing import Dict, List, Optional, Tuple

# ------------------- Bepaal of GUI beschikbaar is -------------------
GUI_ACTIVE = '--mode' in sys.argv and sys.argv[sys.argv.index('--mode')+1] == 'gui' if '--mode' in sys.argv else (len(sys.argv) == 1)
if GUI_ACTIVE:
try:
from tkinter import *
from tkinter import ttk, filedialog, messagebox, scrolledtext
GUI_AVAILABLE = True
except ImportError:
GUI_AVAILABLE = False
print("Waarschuwing: Tkinter niet beschikbaar. GUI modus werkt niet.")
else:
GUI_AVAILABLE = False

# ------------------- Optionele AI -------------------
try:
from transformers import pipeline
AI_AVAILABLE = True
except ImportError:
AI_AVAILABLE = False

# ------------------- Configuratie -------------------
DEFAULT_CONFIG = {
'Paths': {
'scan_dir': '/media/hdd',
'archive_dir': str(Path.home() / 'Desktop' / 'Administratie')
},
'Settings': {
'max_depth': '4',
'scan_time': '18:00',
'auto_mode': 'True',
'ai_enabled': 'False'
}
}

def laad_config(config_pad: Path = None) -> configparser.ConfigParser:
if config_pad is None:
config_pad = Path.home() / '.hvac_admin' / 'config.ini'
config_pad.parent.mkdir(parents=True, exist_ok=True)

config = configparser.ConfigParser()
if config_pad.exists():
config.read(config_pad)
else:
for section, values in DEFAULT_CONFIG.items():
config[section] = values
with open(config_pad, 'w') as f:
config.write(f)
return config

def bewaar_config(config: configparser.ConfigParser, config_pad: Path = None):
if config_pad is None:
config_pad = Path.home() / '.hvac_admin' / 'config.ini'
config_pad.parent.mkdir(parents=True, exist_ok=True)
with open(config_pad, 'w') as f:
config.write(f)

# ------------------- Documentherkenning -------------------
DOC_TYPES = {
"offerte": "Offertes", "off": "Offertes",
"factuur": "Facturen", "fact": "Facturen",
"creditnota": "Creditnotas", "credit": "Creditnotas",
"verkoopsvoorwaarden": "Algemeen/Verkoopsvoorwaarden", "terms": "Algemeen/Verkoopsvoorwaarden",
"warmtepomp": "Warmtepompen/Onderhoud", "lektest": "Warmtepompen/Lektesten", "installatie": "Warmtepompen/Installaties",
"hydraulisch": "Hydraulica/Groot onderhoud", "regeling": "Hydraulica/Regelingen",
"reinigingsattest": "Attesten/Reiniging gasvormig", "gasvormig": "Attesten/Reiniging gasvormig",
"vloeibare brandstof": "Attesten/Reiniging vloeibare brandstof",
"verbrandingsattest": "Attesten/Verbranding",
"onderhoudscontract": "Contracten/Onderhoud",
"klantenlisting": "Klanten/Overzichten",
"technische fiche": "Technische fiches",
"garantie": "Garanties",
"leveringsbon": "Leveringsbonnen",
"stookolie": "Stookolie/Bestellingen",
"afkeuring": "Rapporten/Afkeuringen",
"keuring": "Rapporten/Keuringen",
}
AI_LABELS = list(DOC_TYPES.keys())

def detecteer_type(bestandsnaam: str, classifier=None) -> Tuple[Optional[str], float]:
naam_lower = bestandsnaam.lower()
for trefwoord, mapnaam in DOC_TYPES.items():
if trefwoord in naam_lower:
return mapnaam, 1.0
if classifier and AI_AVAILABLE:
try:
result = classifier(bestandsnaam, AI_LABELS)
if result['scores'][0] > 0.5:
return DOC_TYPES.get(result['labels'][0]), result['scores'][0]
except:
pass
return None, 0.0

def sorteer_bestand(bestandspad: Path, archiefmap: Path, log_callback=None, classifier=None) -> bool:
try:
if not bestandspad.is_file():
return False
doelmap_rel, _ = detecteer_type(bestandspad.name, classifier)
if not doelmap_rel:
if log_callback:
log_callback(f"⚠️ Onbekend type: {bestandspad.name}")
return False
jaar = datetime.now().year
doelpad = archiefmap / str(jaar) / doelmap_rel / bestandspad.name
doelpad.parent.mkdir(parents=True, exist_ok=True)
if doelpad.exists():
ts = datetime.now().strftime("%Y%m%d_%H%M%S")
naam = doelpad.stem + f"_{ts}" + doelpad.suffix
doelpad = doelpad.parent / naam
shutil.move(str(bestandspad), str(doelpad))
if log_callback:
log_callback(f"✅ {bestandspad.name} → {jaar}/{doelmap_rel}")
return True
except Exception as e:
if log_callback:
log_callback(f"❌ Fout: {bestandspad.name} - {str(e)}")
return False

def scan_en_sorteer(scan_dir: Path, archief_dir: Path, max_depth: int = 4,
log_callback=None, classifier=None) -> int:
if log_callback:
log_callback(f"🔍 Scannen van {scan_dir} tot {max_depth} niveaus diep...")
gevonden = []

def walk(pad: Path, diepte: int):
if diepte > max_depth:
return
try:
for item in pad.iterdir():
if item.is_file():
gevonden.append(item)
elif item.is_dir():
walk(item, diepte + 1)
except PermissionError:
pass
except Exception:
pass

walk(scan_dir, 0)
totaal = len(gevonden)
if log_callback:
log_callback(f"📊 {totaal} bestanden gevonden. Sorteren...")

succes = 0
for i, bestand in enumerate(gevonden):
if sorteer_bestand(bestand, archief_dir, log_callback, classifier):
succes += 1
if log_callback and (i + 1) % 50 == 0:
log_callback(f"📦 Voortgang: {i+1}/{totaal} bestanden verwerkt...")

if log_callback:
log_callback(f"✅ Klaar! {succes} van {totaal} bestanden gesorteerd.")
return succes

# ------------------- CLI modus -------------------
def run_cli_scan(scan_dir: str, archive_dir: str, depth: int, ai_enabled: bool):
scan_pad = Path(scan_dir).expanduser().resolve()
archive_pad = Path(archive_dir).expanduser().resolve()

if not scan_pad.exists():
print(f"❌ Fout: scanmap {scan_pad} bestaat niet.")
return

archive_pad.mkdir(parents=True, exist_ok=True)
print(f"📁 Archiefmap: {archive_pad}")

classifier = None
if ai_enabled and AI_AVAILABLE:
try:
print("🤖 AI-model laden (eenmalig)...")
classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
print("✅ AI geladen.")
except Exception as e:
print(f"⚠️ AI kon niet geladen worden: {e}. Valt terug op trefwoorden.")

scan_en_sorteer(scan_pad, archive_pad, depth, lambda m: print(m), classifier)

# ------------------- GUI modus -------------------
def start_gui():
if not GUI_AVAILABLE:
print("Tkinter niet beschikbaar. Installeer python3-tk of gebruik CLI modus.")
return

root = Tk()
root.title("🏢 HVAC ADMIN - Professionele Sorteerder")
root.geometry("900x800")
root.configure(bg='#1a1a2e')

# Laad opgeslagen instellingen
config = laad_config()
saved_scan_dir = config.get('Paths', 'scan_dir', fallback=str(Path.home() / "Downloads"))
saved_archive_dir = config.get('Paths', 'archive_dir', fallback=str(Path.home() / "Desktop" / "Administratie"))
saved_depth = config.getint('Settings', 'max_depth', fallback=4)

bg = '#1a1a2e'
fg = '#eeeeee'
accent = '#0f3460'
highlight = '#e94560'

main = Frame(root, bg=bg)
main.pack(fill=BOTH, expand=True, padx=20, pady=20)

# Titel
title_frame = Frame(main, bg=bg)
title_frame.pack(fill=X, pady=(0, 20))
Label(title_frame, text="🏢 HVAC ADMIN", font=('Arial', 24, 'bold'),
bg=bg, fg=highlight).pack()
Label(title_frame, text="Professionele Document Sorteerder", font=('Arial', 11),
bg=bg, fg=fg).pack()

# Instellingen Frame
settings_frame = LabelFrame(main, text="📁 Instellingen", bg=bg, fg=fg,
font=('Arial', 12, 'bold'), padx=10, pady=10)
settings_frame.pack(fill=X, pady=10)

# Scan directory
row1 = Frame(settings_frame, bg=bg)
row1.pack(fill=X, pady=8)
Label(row1, text="Bronmap:", bg=bg, fg=fg, width=12, anchor=W,
font=('Arial', 10)).pack(side=LEFT)
scan_dir_var = StringVar(value=saved_scan_dir)
Entry(row1, textvariable=scan_dir_var, width=55, bg='#16213e', fg=fg,
font=('Arial', 10), insertbackground='white').pack(side=LEFT, padx=5)

def browse_scan():
folder = filedialog.askdirectory(title="Selecteer bronmap om te scannen")
if folder:
scan_dir_var.set(folder)

Button(row1, text="📂 Bladeren", command=browse_scan, bg=accent, fg=fg,
font=('Arial', 10), cursor='hand2').pack(side=LEFT)

# Archief directory
row2 = Frame(settings_frame, bg=bg)
row2.pack(fill=X, pady=8)
Label(row2, text="Archiefmap:", bg=bg, fg=fg, width=12, anchor=W,
font=('Arial', 10)).pack(side=LEFT)
arch_dir_var = StringVar(value=saved_archive_dir)
Entry(row2, textvariable=arch_dir_var, width=55, bg='#16213e', fg=fg,
font=('Arial', 10), insertbackground='white').pack(side=LEFT, padx=5)

def browse_archive():
folder = filedialog.askdirectory(title="Selecteer archiefmap voor gesorteerde documenten")
if folder:
arch_dir_var.set(folder)

Button(row2, text="📂 Bladeren", command=browse_archive, bg=accent, fg=fg,
font=('Arial', 10), cursor='hand2').pack(side=LEFT)

# Diepte
row3 = Frame(settings_frame, bg=bg)
row3.pack(fill=X, pady=8)
Label(row3, text="Scan diepte:", bg=bg, fg=fg, width=12, anchor=W,
font=('Arial', 10)).pack(side=LEFT)
depth_var = IntVar(value=saved_depth)
Spinbox(row3, from_=1, to=4, textvariable=depth_var, width=8,
bg='#16213e', fg=fg, font=('Arial', 10)).pack(side=LEFT, padx=5)
Label(row3, text="niveaus (1-4)", bg=bg, fg=fg, font=('Arial', 9)).pack(side=LEFT, padx=5)

# Knoppen voor opslaan
row4 = Frame(settings_frame, bg=bg)
row4.pack(fill=X, pady=8)

def save_settings():
config.set('Paths', 'scan_dir', scan_dir_var.get())
config.set('Paths', 'archive_dir', arch_dir_var.get())
config.set('Settings', 'max_depth', str(depth_var.get()))
bewaar_config(config)
log("💾 Instellingen opgeslagen!")
messagebox.showinfo("Opgeslagen", "Instellingen zijn opgeslagen voor de volgende keer.")

Button(row4, text="💾 Instellingen Opslaan", command=save_settings,
bg='#27ae60', fg='white', font=('Arial', 10), cursor='hand2').pack(side=LEFT, padx=5)

# Logboek Frame
log_frame = LabelFrame(main, text="📋 Logboek", bg=bg, fg=fg,
font=('Arial', 12, 'bold'), padx=10, pady=10)
log_frame.pack(fill=BOTH, expand=True, pady=10)

# Log controls
log_controls = Frame(log_frame, bg=bg)
log_controls.pack(fill=X, pady=(0, 5))
Button(log_controls, text="🗑 Wissen", command=lambda: log_text.delete(1.0, END),
bg=accent, fg=fg, font=('Arial', 9), cursor='hand2').pack(side=LEFT, padx=2)

log_text = scrolledtext.ScrolledText(log_frame, bg='#16213e', fg=fg,
font=('Consolas', 10), height=15)
log_text.pack(fill=BOTH, expand=True)

def log(msg):
timestamp = datetime.now().strftime("%H:%M:%S")
log_text.insert(END, f"[{timestamp}] {msg}\n")
log_text.see(END)
root.update_idletasks()

# Sorteer knop
def do_sort():
scan_pad = Path(scan_dir_var.get())
arch_pad = Path(arch_dir_var.get())
depth = depth_var.get()

if not scan_pad.exists():
messagebox.showerror("Fout", f"Bronmap bestaat niet:\n{scan_pad}")
return

if not arch_pad.exists():
if messagebox.askyesno("Map bestaat niet", f"Archiefmap bestaat niet:\n{arch_pad}\n\nWil je deze aanmaken?"):
arch_pad.mkdir(parents=True, exist_ok=True)
log(f"📁 Archiefmap aangemaakt: {arch_pad}")
else:
return

log("🚀 Gestart met sorteren...")
log(f"📂 Bron: {scan_pad}")
log(f"📁 Doel: {arch_pad}")
log(f"📊 Diepte: {depth} niveaus")

root.config(cursor="watch")
root.update()

try:
succes = scan_en_sorteer(scan_pad, arch_pad, depth, log, classifier=None)
log(f"✨ Klaar! {succes} bestanden succesvol gesorteerd.")
messagebox.showinfo("Voltooid", f"{succes} bestanden zijn gesorteerd!\n\nDoelmap: {arch_pad}")
except Exception as e:
log(f"❌ Fout tijdens sorteren: {str(e)}")
messagebox.showerror("Fout", f"Er is een fout opgetreden:\n{str(e)}")
finally:
root.config(cursor="")

# Start knop
Button(main, text="🚀 START SORTEREN", command=do_sort,
bg='#e67e22', fg='white', font=('Arial', 13, 'bold'),
padx=30, pady=12, cursor='hand2').pack(pady=10)

# Status balk
status_bar = Label(root, text="✅ Klaar voor gebruik", bg='#2c3e50', fg='white',
font=('Arial', 9), anchor=W, padx=10)
status_bar.pack(side=BOTTOM, fill=X)

log("✅ HVAC ADMIN gestart!")
log(f"📁 Archiefmap: {saved_archive_dir}")
log("💡 Je kunt instellingen aanpassen en opslaan")

root.mainloop()

# ------------------- Auto scheduler -------------------
def setup_auto_schedule(scantijd: str):
config = laad_config()
scan_dir = config['Paths']['scan_dir']
archive_dir = config['Paths']['archive_dir']
depth = config.getint('Settings', 'max_depth')
ai_enabled = config.getboolean('Settings', 'ai_enabled')

print(f"🕐 Automatische scan elke dag om {scantijd} uur.")
print(f" Bron: {scan_dir}")
print(f" Doel: {archive_dir}")
print(" (Druk op Ctrl+C om te stoppen)")

last_run = None
while True:
try:
now = datetime.now()
if now.strftime("%H:%M") == scantijd and (last_run is None or last_run.date() != now.date()):
print(f"\n⏰ {now} - Start geplande scan")
run_cli_scan(scan_dir, archive_dir, depth, ai_enabled)
last_run = now
time.sleep(30)
except KeyboardInterrupt:
print("\n👋 Scheduler gestopt door gebruiker")
break
except Exception as e:
print(f"⚠️ Fout in scheduler: {e}")
time.sleep(60)

# ------------------- Main -------------------
def main():
parser = argparse.ArgumentParser(description='HVAC Document Sorteerder')
parser.add_argument('-m', '--mode', choices=['gui', 'cli', 'auto'], default='gui',
help='Startmodus: gui (grafisch), cli (terminal), auto (dagelijkse scheduler)')
parser.add_argument('-s', '--scan-dir', type=str, help='Bronmap voor CLI modus')
parser.add_argument('-a', '--archive-dir', type=str, help='Doelmap voor CLI modus')
parser.add_argument('-d', '--depth', type=int, default=4, choices=range(1,5),
help='Maximale scan diepte (1-4)')
parser.add_argument('-t', '--time', type=str, default='18:00',
help='Scantijd voor auto modus (24u formaat, bv 18:00)')
args = parser.parse_args()

if args.mode == 'gui':
start_gui()
elif args.mode == 'cli':
if not args.scan_dir or not args.archive_dir:
print("Fout: bij --mode cli zijn --scan-dir en --archive-dir verplicht")
print("Voorbeeld: python3 hvac_admin.py --mode cli --scan-dir /home/pi/Downloads --archive-dir /home/pi/Desktop/Administratie")
sys.exit(1)
config = laad_config()
ai_enabled = config.getboolean('Settings', 'ai_enabled')
run_cli_scan(args.scan_dir, args.archive_dir, args.depth, ai_enabled)
elif args.mode == 'auto':
setup_auto_schedule(args.time)
else:
parser.print_help()

if __name__ == '__main__':
main()

Bash linux mappen structuur 

Met bash maak je de mappen structuur voor linux aan met python sorteer je ze