""" Mail-Fetcher Modul Holt Attachments aus IMAP-Postfächern """ import imaplib import email from email.header import decode_header from pathlib import Path from datetime import datetime from typing import List, Dict, Optional import logging from ..config import INBOX_DIR logger = logging.getLogger(__name__) class MailFetcher: """Holt Attachments aus einem IMAP-Postfach""" def __init__(self, config: Dict): """ Args: config: Dict mit imap_server, imap_port, email, passwort, ordner, erlaubte_typen, max_groesse_mb """ self.config = config self.connection = None def connect(self) -> bool: """Verbindung zum IMAP-Server herstellen""" try: self.connection = imaplib.IMAP4_SSL( self.config["imap_server"], self.config.get("imap_port", 993) ) self.connection.login( self.config["email"], self.config["passwort"] ) return True except Exception as e: logger.error(f"IMAP Verbindungsfehler: {e}") return False def disconnect(self): """Verbindung trennen""" if self.connection: try: self.connection.logout() except: pass self.connection = None def liste_ordner(self) -> List[str]: """Listet alle verfügbaren IMAP-Ordner""" if not self.connection: if not self.connect(): return [] try: status, folders = self.connection.list() ordner_liste = [] if status == "OK": for folder in folders: if isinstance(folder, bytes): # Format: (flags) "delimiter" "name" parts = folder.decode().split(' "') if len(parts) >= 3: name = parts[-1].strip('"') ordner_liste.append(name) else: # Fallback ordner_liste.append(folder.decode().split()[-1].strip('"')) return ordner_liste except Exception as e: logger.error(f"Fehler beim Auflisten der Ordner: {e}") return [] def fetch_attachments(self, ziel_ordner: Optional[Path] = None, nur_ungelesen: bool = False, markiere_gelesen: bool = False, alle_ordner: bool = False, bereits_verarbeitet: set = None) -> List[Dict]: """ Holt alle Attachments die den Filtern entsprechen Args: alle_ordner: Wenn True, werden ALLE IMAP-Ordner durchsucht bereits_verarbeitet: Set von Message-IDs die übersprungen werden Returns: Liste von Dicts mit: pfad, original_name, absender, betreff, datum, groesse, message_id """ if not self.connection: if not self.connect(): return [] ziel = ziel_ordner or INBOX_DIR ziel.mkdir(parents=True, exist_ok=True) ergebnisse = [] erlaubte_typen = self.config.get("erlaubte_typen", [".pdf"]) max_groesse = self.config.get("max_groesse_mb", 25) * 1024 * 1024 min_groesse = self.config.get("min_groesse_kb", 10) * 1024 # Mindestgröße in Bytes groessen_filter = self.config.get("groessen_filter", {}) # Pro Dateityp: {".pdf": {"min_kb": 10, "max_mb": 25}} bereits_verarbeitet = bereits_verarbeitet or set() # Ordner bestimmen if alle_ordner: ordner_liste = self.liste_ordner() logger.info(f"Durchsuche {len(ordner_liste)} Ordner") else: ordner_liste = [self.config.get("ordner", "INBOX")] for ordner in ordner_liste: ergebnisse.extend(self._fetch_from_folder( ordner, ziel, erlaubte_typen, max_groesse, min_groesse, groessen_filter, nur_ungelesen, markiere_gelesen, bereits_verarbeitet )) return ergebnisse def _fetch_from_folder(self, ordner: str, ziel: Path, erlaubte_typen: List[str], max_groesse: int, min_groesse: int, groessen_filter: dict, nur_ungelesen: bool, markiere_gelesen: bool, bereits_verarbeitet: set) -> List[Dict]: """Holt Attachments aus einem einzelnen Ordner""" ergebnisse = [] try: # Ordner auswählen status, _ = self.connection.select(ordner) if status != "OK": logger.debug(f"Ordner nicht zugreifbar: {ordner}") return [] # Suche nach Mails mit optionalem Datumfilter ab_datum = self.config.get("ab_datum") if nur_ungelesen: search_criteria = "(UNSEEN)" elif ab_datum: # IMAP SINCE erwartet Format: dd-Mon-yyyy try: if isinstance(ab_datum, str): ab_datum = datetime.fromisoformat(ab_datum.replace("Z", "+00:00")) datum_str = ab_datum.strftime("%d-%b-%Y") search_criteria = f'(SINCE {datum_str})' except: search_criteria = "ALL" else: search_criteria = "ALL" status, messages = self.connection.search(None, search_criteria) if status != "OK": logger.warning(f"Keine Mails gefunden in {ordner}") return [] mail_ids = messages[0].split() logger.info(f"Gefunden: {len(mail_ids)} Mails in {ordner}") for mail_id in mail_ids: try: # Mail abrufen status, msg_data = self.connection.fetch(mail_id, "(RFC822)") if status != "OK": continue msg = email.message_from_bytes(msg_data[0][1]) # Message-ID extrahieren und prüfen ob bereits verarbeitet message_id = msg.get("Message-ID", "") if message_id and message_id in bereits_verarbeitet: continue # Bereits verarbeitet, überspringen # Metadaten extrahieren absender = self._decode_header(msg.get("From", "")) betreff = self._decode_header(msg.get("Subject", "")) datum = msg.get("Date", "") # Attachments durchgehen for part in msg.walk(): if part.get_content_maintype() == "multipart": continue filename = part.get_filename() if not filename: continue filename = self._decode_header(filename) datei_endung = Path(filename).suffix.lower() # Filter prüfen if datei_endung not in erlaubte_typen: logger.debug(f"Überspringe {filename}: Typ {datei_endung} nicht erlaubt") continue payload = part.get_payload(decode=True) if not payload: continue # Größenlimits: Pro Dateityp oder global typ_filter = groessen_filter.get(datei_endung, {}) typ_max = typ_filter.get("max_mb", max_groesse / (1024 * 1024)) * 1024 * 1024 typ_min = typ_filter.get("min_kb", min_groesse / 1024) * 1024 if len(payload) > typ_max: logger.warning(f"Überspringe {filename}: Zu groß ({len(payload)} bytes, max {typ_max})") continue if len(payload) < typ_min: logger.debug(f"Überspringe {filename}: Zu klein ({len(payload)} bytes, min {typ_min})") continue # Speichern timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") safe_filename = self._safe_filename(filename) ziel_pfad = ziel / f"{timestamp}_{safe_filename}" # Eindeutigen Namen sicherstellen counter = 1 while ziel_pfad.exists(): ziel_pfad = ziel / f"{timestamp}_{counter}_{safe_filename}" counter += 1 ziel_pfad.write_bytes(payload) ergebnisse.append({ "pfad": str(ziel_pfad), "original_name": filename, "absender": absender, "betreff": betreff, "datum": datum, "groesse": len(payload), "message_id": message_id, "ordner": ordner }) logger.info(f"Gespeichert: {ziel_pfad.name}") # Als gelesen markieren if markiere_gelesen and ergebnisse: self.connection.store(mail_id, "+FLAGS", "\\Seen") except Exception as e: logger.error(f"Fehler bei Mail {mail_id}: {e}") continue except imaplib.IMAP4.error as e: # IMAP-Fehler beim Ordner-Zugriff (z.B. nicht existent, keine Berechtigung) logger.debug(f"Ordner übersprungen: {ordner} - {e}") except Exception as e: logger.error(f"Fehler beim Abrufen aus {ordner}: {e}") return ergebnisse def _decode_header(self, value: str) -> str: """Dekodiert Email-Header (kann encoded sein)""" if not value: return "" try: decoded_parts = decode_header(value) result = [] for part, charset in decoded_parts: if isinstance(part, bytes): result.append(part.decode(charset or "utf-8", errors="replace")) else: result.append(part) return " ".join(result) except: return str(value) def _safe_filename(self, filename: str) -> str: """Macht Dateinamen sicher für Dateisystem""" # Ungültige Zeichen ersetzen invalid_chars = '<>:"/\\|?*' for char in invalid_chars: filename = filename.replace(char, "_") return filename.strip() def fetch_attachments_generator(self, ziel_ordner: Optional[Path] = None, nur_ungelesen: bool = False, markiere_gelesen: bool = False, alle_ordner: bool = False, bereits_verarbeitet: set = None): """ Generator-Version für Streaming - yielded Events während des Abrufs Yields: Dict mit type: "ordner", "mails", "datei", "skip", "fehler" """ if not self.connection: if not self.connect(): yield {"type": "fehler", "nachricht": "Verbindung fehlgeschlagen"} return ziel = ziel_ordner or INBOX_DIR ziel.mkdir(parents=True, exist_ok=True) erlaubte_typen = self.config.get("erlaubte_typen", [".pdf"]) max_groesse = self.config.get("max_groesse_mb", 25) * 1024 * 1024 min_groesse = self.config.get("min_groesse_kb", 10) * 1024 groessen_filter = self.config.get("groessen_filter", {}) # Pro Dateityp bereits_verarbeitet = bereits_verarbeitet or set() # Ordner bestimmen if alle_ordner: ordner_liste = self.liste_ordner() yield {"type": "info", "nachricht": f"{len(ordner_liste)} Ordner gefunden"} else: ordner_liste = [self.config.get("ordner", "INBOX")] for ordner in ordner_liste: yield {"type": "ordner", "name": ordner} try: status, _ = self.connection.select(ordner) if status != "OK": # Ordner konnte nicht geöffnet werden (nicht zugreifbar) logger.debug(f"Ordner nicht zugreifbar: {ordner}") continue # Suche mit optionalem Datumfilter ab_datum = self.config.get("ab_datum") if nur_ungelesen: search_criteria = "(UNSEEN)" elif ab_datum: try: if isinstance(ab_datum, str): ab_datum = datetime.fromisoformat(ab_datum.replace("Z", "+00:00")) datum_str = ab_datum.strftime("%d-%b-%Y") search_criteria = f'(SINCE {datum_str})' except: search_criteria = "ALL" else: search_criteria = "ALL" status, messages = self.connection.search(None, search_criteria) if status != "OK": continue mail_ids = messages[0].split() yield {"type": "mails", "ordner": ordner, "anzahl": len(mail_ids)} for mail_id in mail_ids: try: status, msg_data = self.connection.fetch(mail_id, "(RFC822)") if status != "OK": continue msg = email.message_from_bytes(msg_data[0][1]) message_id = msg.get("Message-ID", "") if message_id and message_id in bereits_verarbeitet: continue absender = self._decode_header(msg.get("From", "")) betreff = self._decode_header(msg.get("Subject", "")) datum = msg.get("Date", "") for part in msg.walk(): if part.get_content_maintype() == "multipart": continue filename = part.get_filename() if not filename: continue filename = self._decode_header(filename) datei_endung = Path(filename).suffix.lower() if datei_endung not in erlaubte_typen: continue payload = part.get_payload(decode=True) if not payload: continue # Größenlimits: Pro Dateityp oder global typ_filter = groessen_filter.get(datei_endung, {}) typ_max = typ_filter.get("max_mb", max_groesse / (1024 * 1024)) * 1024 * 1024 typ_min = typ_filter.get("min_kb", min_groesse / 1024) * 1024 if len(payload) > typ_max: yield {"type": "skip", "datei": filename, "grund": f"zu groß ({len(payload)//1024}KB > {int(typ_max//1024)}KB)"} continue if len(payload) < typ_min: yield {"type": "skip", "datei": filename, "grund": f"zu klein ({len(payload)//1024}KB < {int(typ_min//1024)}KB)"} continue timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") safe_filename = self._safe_filename(filename) ziel_pfad = ziel / f"{timestamp}_{safe_filename}" counter = 1 while ziel_pfad.exists(): ziel_pfad = ziel / f"{timestamp}_{counter}_{safe_filename}" counter += 1 ziel_pfad.write_bytes(payload) yield { "type": "datei", "pfad": str(ziel_pfad), "original_name": filename, "absender": absender, "betreff": betreff[:100] if betreff else "", "datum": datum, "groesse": len(payload), "message_id": message_id, "ordner": ordner } if markiere_gelesen: self.connection.store(mail_id, "+FLAGS", "\\Seen") except Exception as e: yield {"type": "fehler", "nachricht": f"Mail-Fehler: {str(e)[:100]}"} continue except imaplib.IMAP4.error as e: # IMAP-Fehler beim Ordner-Zugriff (z.B. nicht existent, keine Berechtigung) # Diese Fehler sind normal bei "alle_ordner" und werden nur geloggt logger.debug(f"Ordner übersprungen (nicht zugreifbar): {ordner} - {e}") continue except Exception as e: # Andere unerwartete Fehler werden als Warnung gemeldet logger.warning(f"Ordner-Fehler {ordner}: {e}") continue def test_connection(self) -> Dict: """Testet die Verbindung und gibt Status zurück""" try: if self.connect(): # Ordner auflisten status, folders = self.connection.list() ordner_liste = [] if status == "OK": for folder in folders: if isinstance(folder, bytes): ordner_liste.append(folder.decode()) self.disconnect() return { "erfolg": True, "nachricht": "Verbindung erfolgreich", "ordner": ordner_liste } else: return { "erfolg": False, "nachricht": "Verbindung fehlgeschlagen" } except Exception as e: return { "erfolg": False, "nachricht": str(e) }