import imaplib import time import threading import queue import json import os import logging import subprocess import email import email.header import email.utils import tkinter as tk from tkinter import messagebox, filedialog, ttk from PIL import Image, ImageDraw import pystray # --- Logging postavljanje --- LOG_FILE = "mail_checker.log" logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", handlers=[ logging.FileHandler(LOG_FILE, encoding="utf-8"), logging.StreamHandler() ] ) logger = logging.getLogger(__name__) # --- Konfiguracija --- CONFIG_FILE = "config.json" MAX_RETRIES = 3 RETRY_DELAY = 5 # sekundi između ponovnih pokušaja # --- Globalno stanje zaštićeno lockom --- _state_lock = threading.Lock() last_unread_counts = {} # {mail_user: count | None} None = još nije provjeravano is_running = True tray_icon = None config_accounts = [] # --- Red čekanja za TTS — govori se serijski, ne paralelno --- _tts_queue: queue.Queue = queue.Queue() def _tts_worker(): """Pozadinska nit koja izvršava TTS poruke jednu po jednu.""" while True: item = _tts_queue.get() if item is None: break text, gender = item voice_variant = "hr+f3" if gender == "Female" else "hr" try: subprocess.run( ["espeak-ng", "-v", voice_variant, "-s", "150", text], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, ) except FileNotFoundError: logger.warning("espeak-ng nije pronađen.") finally: _tts_queue.task_done() _tts_thread = threading.Thread(target=_tts_worker, daemon=True) _tts_thread.start() # --------------------------------------------------------------------------- # Keyring / enkripcija lozinke # --------------------------------------------------------------------------- try: import keyring _USE_KEYRING = True except ImportError: _USE_KEYRING = False # Fernet enkripcija kao fallback kad keyring nije dostupan _CRYPTO_KEY_FILE = ".mail_checker.key" def _get_fernet(): try: from cryptography.fernet import Fernet if not os.path.exists(_CRYPTO_KEY_FILE): key = Fernet.generate_key() with open(_CRYPTO_KEY_FILE, "wb") as f: f.write(key) os.chmod(_CRYPTO_KEY_FILE, 0o600) else: with open(_CRYPTO_KEY_FILE, "rb") as f: key = f.read() return Fernet(key) except ImportError: return None except Exception as exc: logger.error("Greška pri učitavanju ključa: %s", exc) return None _fernet = None if _USE_KEYRING else _get_fernet() if not _USE_KEYRING and _fernet is None: logger.warning("Ni keyring ni cryptography nisu dostupni. Lozinke se čuvaju nezaštićeno.") logger.warning("Instaliraj: pip install cryptography --break-system-packages") KEYRING_SERVICE = "MailChecker" def _save_password(user: str, password: str) -> str: """Sprema lozinku — keychain > Fernet enkripcija > plain text.""" if _USE_KEYRING: keyring.set_password(KEYRING_SERVICE, user, password) return "" if _fernet: return _fernet.encrypt(password.encode()).decode() return password # fallback — plain text def _get_password(acc: dict) -> str: """Dohvaća lozinku iz keychaina ili dekriptira iz JSON-a.""" if _USE_KEYRING: pwd = keyring.get_password(KEYRING_SERVICE, acc["MAIL_USER"]) return pwd or "" raw = acc.get("MAIL_PASSWORD", "") if _fernet and raw: try: return _fernet.decrypt(raw.encode()).decode() except Exception: return raw # nije enkriptirana (stari zapis) — vrati kao jest return raw # --------------------------------------------------------------------------- # Konfiguracija (load / save) # --------------------------------------------------------------------------- def load_config(): global config_accounts if not os.path.exists(CONFIG_FILE): config_accounts = [] return try: with open(CONFIG_FILE, "r", encoding="utf-8") as f: data = json.load(f) if isinstance(data, list): config_accounts = data elif isinstance(data, dict) and data: config_accounts = [data] else: config_accounts = [] except Exception as exc: logger.error("Greška pri učitavanju konfiguracije: %s", exc) config_accounts = [] def save_config(): """Sprema konfiguraciju — lozinke u keychain ako je dostupan, inače u JSON.""" to_save = [] for acc in config_accounts: if _USE_KEYRING: # Keychain čuva lozinku — ne treba u JSON entry = {k: v for k, v in acc.items() if k != "MAIL_PASSWORD"} else: # Nema keychaina — lozinka ostaje u JSON (upozorenje je već ispisano) entry = dict(acc) to_save.append(entry) try: with open(CONFIG_FILE, "w", encoding="utf-8") as f: json.dump(to_save, f, indent=4, ensure_ascii=False) except Exception as exc: logger.error("Greška pri snimanju konfiguracije: %s", exc) # --------------------------------------------------------------------------- # Zvuk i TTS — bez shell injection # --------------------------------------------------------------------------- def speak_text(text: str, gender: str = "Female"): """Dodaje TTS poruku u red čekanja — govori se serijski, ne paralelno.""" _tts_queue.put((text, gender)) def play_sound_file(file_path: str): """Reproducira zvučnu datoteku bez shell injection.""" if not file_path or not os.path.exists(file_path): return def _find_player(candidates: list[str]) -> str | None: for player in candidates: try: subprocess.run(["which", player], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) return player except subprocess.CalledProcessError: continue return None def _run(): ext = file_path.lower().rsplit(".", 1)[-1] if ext == "wav": player = _find_player(["aplay", "paplay"]) if player: subprocess.run([player, file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) else: player = _find_player(["mpv", "ffplay", "paplay"]) if player == "mpv": subprocess.run(["mpv", "--no-video", file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) elif player == "ffplay": subprocess.run(["ffplay", "-nodisp", "-autoexit", file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) elif player: subprocess.run([player, file_path], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) threading.Thread(target=_run, daemon=True).start() def _send_notification(title: str, body: str): """Šalje desktop notifikaciju u zasebnom threadu — greške ne ruše tray.""" def _run(): try: subprocess.run( ["notify-send", "--expire-time=5000", title, body], check=False, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5, ) except FileNotFoundError: logger.warning("notify-send nije pronađen.") except Exception as exc: logger.warning("notify-send greška (ignorirana): %s", exc) threading.Thread(target=_run, daemon=True).start() # --------------------------------------------------------------------------- # Hrvatska deklinacija # --------------------------------------------------------------------------- def get_croatian_mail_word(count: int) -> str: if count % 100 in range(11, 15): return "poruka" last = count % 10 if last == 1: return "poruku" if last in (2, 3, 4): return "poruke" return "poruka" # --------------------------------------------------------------------------- # Provjera maila — s retry i ispravnim cleanup-om # --------------------------------------------------------------------------- def _check_single_account(acc: dict) -> int | None: """ Provjerava nepročitane mailove za jedan račun. Vraća broj nepročitanih ili None ako provjera ne uspije ni nakon retry-a. """ server = acc["IMAP_SERVER"] user = acc["MAIL_USER"] password = _get_password(acc) for attempt in range(1, MAX_RETRIES + 1): mail = None try: mail = imaplib.IMAP4_SSL(server, timeout=15) mail.login(user, password) mail.select("inbox") status, response = mail.search(None, "UNSEEN") if status == "OK": return len(response[0].split()) logger.warning("[%s] IMAP search vratio status: %s", user, status) return None except imaplib.IMAP4.error as exc: # Auth greška — nema smisla retry logger.error("[%s] Auth/IMAP greška: %s", user, exc) return None except Exception as exc: logger.warning("[%s] Pokušaj %d/%d nije uspio: %s", user, attempt, MAX_RETRIES, exc) if attempt < MAX_RETRIES: time.sleep(RETRY_DELAY * attempt) # exponential backoff finally: if mail: try: mail.logout() except Exception: pass return None def check_all_mails(): global last_unread_counts, tray_icon, config_accounts with _state_lock: accounts_snapshot = list(config_accounts) if not accounts_snapshot: if tray_icon: tray_icon.icon = create_icon_image("gray", 0) tray_icon.title = "Mail Checker: Nema konfiguriranih računa" return total_unread = 0 any_error = False for acc in accounts_snapshot: user = acc["MAIL_USER"] sound = acc.get("SOUND_FILE", "") voice_enabled = acc.get("VOICE_ALERT", True) voice_gender = acc.get("VOICE_GENDER", "Female") current_count = _check_single_account(acc) with _state_lock: previous_count = last_unread_counts.get(user) # None = prva provjera if current_count is None: any_error = True logger.error("[%s] Provjera neuspješna.", user) with _state_lock: prev = last_unread_counts.get(user) if prev is not None: total_unread += prev continue with _state_lock: last_unread_counts[user] = current_count total_unread += current_count is_first = previous_count is None # Koristi nadimak ako postoji, inače dio emaila prije @ name = acc.get("NICKNAME") or user.split("@")[0] if is_first: # Pokretanje — uvijek obavijesti o trenutnom stanju if current_count > 0: word = get_croatian_mail_word(current_count) _send_notification(f"Mail: {user}", f"Nepročitanih poruka: {current_count}") if sound: play_sound_file(sound) elif voice_enabled: speak_text(f"{name}, imate {current_count} {word}", gender=voice_gender) logger.info("[%s] Inicijalna provjera: %d nepročitanih.", user, current_count) elif current_count != previous_count: # Broj se promijenio nakon pokretanja if current_count > 0: word = get_croatian_mail_word(current_count) _send_notification( f"Mail: {user}", f"Nova poruka! Ukupno nepročitanih: {current_count}" ) if sound: play_sound_file(sound) elif voice_enabled: speak_text( f"{name}, stigla je nova poruka. Ukupno imate {current_count} {word}", gender=voice_gender ) logger.info("[%s] %d nepročitanih (ranije: %d)", user, current_count, previous_count) else: _send_notification(f"Mail: {user}", "Sve poruke su pročitane.") if voice_enabled: speak_text(f"{name}, nemate novih poruka.", gender=voice_gender) logger.info("[%s] Inbox čist.", user) # Tray ikona if tray_icon: if any_error and total_unread == 0: tray_icon.icon = create_icon_image("gray", 0) tray_icon.title = "Mail Checker: Greška veze na nekim računima" elif total_unread > 0: tray_icon.icon = create_icon_image("green", total_unread) tray_icon.title = f"Mail Checker: {total_unread} ukupno nepročitanih" else: tray_icon.icon = create_icon_image("blue", 0) tray_icon.title = "Mail Checker: Inbox čist" # --------------------------------------------------------------------------- # Background petlja s točnim timerom # --------------------------------------------------------------------------- def background_loop(): while is_running: start = time.monotonic() check_all_mails() elapsed = time.monotonic() - start with _state_lock: accounts_snapshot = list(config_accounts) if accounts_snapshot: intervals = [acc.get("CHECK_INTERVAL", 60) for acc in accounts_snapshot] interval = max(10, min(intervals)) # min 10s da ne spammamo server else: interval = 60 remaining = interval - elapsed if remaining > 0: # Kratki sleep u petlji kako bismo mogli reagirati na is_running = False deadline = time.monotonic() + remaining while is_running and time.monotonic() < deadline: time.sleep(1) # --------------------------------------------------------------------------- # Tray ikona # --------------------------------------------------------------------------- def create_icon_image(color: str = "blue", count: int = 0) -> Image.Image: image = Image.new("RGB", (64, 64), color) draw = ImageDraw.Draw(image) draw.rectangle([12, 18, 52, 46], fill=None, outline="white", width=2) draw.line([12, 18, 32, 32, 52, 18], fill="white", width=2) if count > 0: label = str(count) if count < 100 else "99+" # Crveni krug u donjem desnom kutu draw.ellipse([38, 38, 62, 62], fill="red") # Broj unutar kruga — pozicioniraj ovisno o duljini tx = 44 if len(label) == 1 else 39 draw.text((tx, 40), label, fill="white") return image def on_exit(icon, item): global is_running is_running = False icon.stop() def show_settings_from_tray(icon, item): threading.Thread(target=open_settings_window, daemon=True).start() # --------------------------------------------------------------------------- # GUI — Settings prozor (enkapsuliran, bez globalnog GUI stanja) # --------------------------------------------------------------------------- def open_settings_window(): """Otvara GUI prozor za upravljanje računima.""" load_config() root = tk.Tk() root.title("Mail Checker – Upravljanje računima") root.resizable(True, True) # Prozor se pozicionira na sredinu nakon što tkinter izračuna pravu veličinu root.update_idletasks() root.eval("tk::PlaceWindow . center") # Lokalna varijabla umjesto globalne selected_idx: list[int | None] = [None] # Lijevi stupac (popis) se širi, desni (formular) ostaje fiksne širine root.columnconfigure(0, weight=1) root.columnconfigure(1, weight=0) root.rowconfigure(0, weight=1) # --- Lijeva strana: popis računa --- frame_list = tk.LabelFrame(root, text=" Registrirani računi ") frame_list.grid(row=0, column=0, padx=10, pady=10, sticky="nsew") frame_list.rowconfigure(0, weight=1) frame_list.columnconfigure(0, weight=1) scrollbar_x = tk.Scrollbar(frame_list, orient="horizontal") account_box = tk.Listbox(frame_list, width=30, height=22, xscrollcommand=scrollbar_x.set) scrollbar_x.config(command=account_box.xview) account_box.pack(padx=5, pady=2, fill="both", expand=True) scrollbar_x.pack(padx=5, pady=2, fill="x") frame_order = tk.Frame(frame_list) frame_order.pack(pady=4) def _move(direction: int): """Pomiče odabrani račun gore (-1) ili dolje (+1).""" if selected_idx[0] is None: return idx = selected_idx[0] new_idx = idx + direction if new_idx < 0 or new_idx >= len(config_accounts): return with _state_lock: config_accounts[idx], config_accounts[new_idx] = config_accounts[new_idx], config_accounts[idx] selected_idx[0] = new_idx save_config() refresh_list() account_box.select_set(new_idx) account_box.see(new_idx) tk.Button(frame_order, text="▲ Gore", width=10, command=lambda: _move(-1)).pack(side="left", padx=4) tk.Button(frame_order, text="▼ Dolje", width=10, command=lambda: _move(1)).pack(side="left", padx=4) def refresh_list(): account_box.delete(0, tk.END) for i, acc in enumerate(config_accounts): nickname = acc.get("NICKNAME") or acc.get("MAIL_USER", "Nepoznato") label = f"{i+1}. {nickname}" account_box.insert(tk.END, label) # --- Desna strana: formular --- frame_form = tk.LabelFrame(root, text=" Podaci računa ") frame_form.grid(row=0, column=1, padx=10, pady=10, sticky="n") def _row(label_text: str, row: int, show: str = "") -> tk.Entry: tk.Label(frame_form, text=label_text).grid(row=row, column=0, padx=8, pady=4, sticky="w") entry = tk.Entry(frame_form, width=28, show=show) entry.grid(row=row, column=1, columnspan=2, padx=8, pady=4, sticky="ew") return entry # Redovi 0–5: polja za unos entry_nickname = _row("Nadimak:", 0) entry_server = _row("IMAP Server:", 1) entry_user = _row("Email:", 2) entry_password = _row("Lozinka:", 3, show="*") entry_interval = _row("Interval (sek):", 4) entry_interval.insert(0, "60") entry_sound = _row("Zvučna datoteka:", 5) # Red 6: Browse gumb def on_browse(): path = filedialog.askopenfilename( title="Odaberi zvučnu datoteku", filetypes=[("Audio", "*.mp3 *.wav"), ("Sve datoteke", "*.*")] ) if path: entry_sound.delete(0, tk.END) entry_sound.insert(0, path) tk.Button(frame_form, text="Pretraži...", command=on_browse).grid( row=6, column=1, padx=8, pady=2, sticky="w") # Red 7: TTS checkbox + radio gumbi spol var_voice = tk.BooleanVar(value=True) tk.Checkbutton(frame_form, text="Glasovni alert (TTS)", variable=var_voice).grid( row=7, column=0, padx=8, pady=6, sticky="w") var_gender = tk.StringVar(value="Female") frame_gender = tk.Frame(frame_form) frame_gender.grid(row=7, column=1, columnspan=2, sticky="w") tk.Radiobutton(frame_gender, text="Ženski", variable=var_gender, value="Female").pack(side="left") tk.Radiobutton(frame_gender, text="Muški", variable=var_gender, value="Male").pack(side="left", padx=6) # Red 8: Separator ttk.Separator(frame_form, orient="horizontal").grid( row=8, column=0, columnspan=3, sticky="ew", padx=8, pady=6) # Red 9: Pregled poruka checkbox var_preview = tk.BooleanVar(value=True) tk.Checkbutton(frame_form, text="Prikaži u pregledu poruka", variable=var_preview).grid( row=9, column=0, columnspan=2, padx=8, pady=2, sticky="w") # Red 10: Broj poruka tk.Label(frame_form, text="Broj poruka u pregledu:").grid( row=10, column=0, padx=8, pady=4, sticky="w") entry_preview_count = tk.Entry(frame_form, width=6) entry_preview_count.insert(0, "5") entry_preview_count.grid(row=10, column=1, padx=8, pady=4, sticky="w") # Red 11: Separator ttk.Separator(frame_form, orient="horizontal").grid( row=11, column=0, columnspan=3, sticky="ew", padx=8, pady=6) # Red 12–14: Akcijski gumbi tk.Button(frame_form, text="Dodaj novi račun", width=22, command=lambda: on_add()).grid( row=12, column=0, columnspan=3, padx=8, pady=4) tk.Button(frame_form, text="Ažuriraj račun", width=22, fg="blue", command=lambda: on_update()).grid( row=13, column=0, columnspan=3, padx=8, pady=4) tk.Button(frame_form, text="Obriši odabrani", width=22, fg="red", command=lambda: on_delete()).grid( row=14, column=0, columnspan=3, padx=8, pady=4) # Red 15: Status label lbl_status = tk.Label(frame_form, text="", fg="gray") lbl_status.grid(row=15, column=0, columnspan=3, pady=6) def on_select(event): sel = account_box.curselection() if not sel: return selected_idx[0] = sel[0] acc = config_accounts[sel[0]] entry_nickname.delete(0, tk.END) entry_nickname.insert(0, acc.get("NICKNAME", "")) entry_server.delete(0, tk.END) entry_server.insert(0, acc.get("IMAP_SERVER", "")) entry_user.delete(0, tk.END) entry_user.insert(0, acc.get("MAIL_USER", "")) entry_password.delete(0, tk.END) entry_password.insert(0, _get_password(acc)) entry_interval.delete(0, tk.END) entry_interval.insert(0, str(acc.get("CHECK_INTERVAL", 60))) entry_sound.delete(0, tk.END) entry_sound.insert(0, acc.get("SOUND_FILE", "")) var_voice.set(acc.get("VOICE_ALERT", True)) var_gender.set(acc.get("VOICE_GENDER", "Female")) var_preview.set(acc.get("PREVIEW_ENABLED", True)) entry_preview_count.delete(0, tk.END) entry_preview_count.insert(0, str(acc.get("PREVIEW_COUNT", 5))) lbl_status.config(text="") account_box.bind("<>", on_select) refresh_list() def _read_form() -> dict | None: nickname = entry_nickname.get().strip() server = entry_server.get().strip() user = entry_user.get().strip() password = entry_password.get().strip() interval = entry_interval.get().strip() sound = entry_sound.get().strip() if not all([nickname, server, user, password, interval]): messagebox.showerror("Greška", "Sva polja moraju biti popunjena (uključujući nadimak)!") return None try: int_val = int(interval) if int_val < 10: raise ValueError except ValueError: messagebox.showerror("Greška", "Interval mora biti broj ≥ 10!") return None preview_count_str = entry_preview_count.get().strip() try: preview_count = int(preview_count_str) if preview_count < 1: raise ValueError except ValueError: messagebox.showerror("Greška", "Broj poruka za pregled mora biti broj ≥ 1!") return None return { "NICKNAME": nickname, "IMAP_SERVER": server, "MAIL_USER": user, "MAIL_PASSWORD": password, "CHECK_INTERVAL": int(interval), "SOUND_FILE": sound, "VOICE_ALERT": var_voice.get(), "VOICE_GENDER": var_gender.get(), "PREVIEW_ENABLED": var_preview.get(), "PREVIEW_COUNT": preview_count, } def _test_connection(server: str, user: str, password: str) -> bool: """Testira IMAP vezu — poziva se iz background threada, GUI se ažurira kroz root.after.""" root.after(0, lambda: lbl_status.config(text="Testiranje veze...", fg="gray")) mail = None try: logger.info("Testiranje veze: %s / %s", server, user) mail = imaplib.IMAP4_SSL(server, timeout=10) mail.login(user, password) logger.info("Test veze uspješan: %s", user) return True except Exception as exc: logger.error("Test veze neuspješan: %s — %s", user, exc) root.after(0, lambda e=exc: lbl_status.config(text=f"Greška: {e}", fg="red")) return False finally: if mail: try: mail.logout() except Exception: pass def _clear_form(): for entry in (entry_nickname, entry_server, entry_user, entry_password, entry_sound): entry.delete(0, tk.END) entry_interval.delete(0, tk.END) entry_interval.insert(0, "60") entry_preview_count.delete(0, tk.END) entry_preview_count.insert(0, "5") var_preview.set(True) selected_idx[0] = None lbl_status.config(text="") def on_add(): data = _read_form() if not data: return if any(a["MAIL_USER"] == data["MAIL_USER"] for a in config_accounts): messagebox.showerror("Greška", "Račun s ovim emailom već postoji!") return if any(a.get("NICKNAME", "").lower() == data["NICKNAME"].lower() for a in config_accounts): messagebox.showerror("Greška", "Račun s ovim nadimkom već postoji!") return def _do(): if not _test_connection(data["IMAP_SERVER"], data["MAIL_USER"], data["MAIL_PASSWORD"]): return # Enkriptiraj / pohrani lozinku pwd = data["MAIL_PASSWORD"] if _USE_KEYRING: data.pop("MAIL_PASSWORD") _save_password(data["MAIL_USER"], pwd) else: data["MAIL_PASSWORD"] = _save_password(data["MAIL_USER"], pwd) with _state_lock: config_accounts.append(data) save_config() logger.info("Račun dodan: %s", data["MAIL_USER"]) root.after(0, lambda: (refresh_list(), _clear_form(), lbl_status.config(text="Račun dodan!", fg="green"), threading.Thread(target=check_all_mails, daemon=True).start())) threading.Thread(target=_do, daemon=True).start() def on_update(): if selected_idx[0] is None: messagebox.showerror("Greška", "Odaberi račun za ažuriranje!") return idx = selected_idx[0] data = _read_form() if not data: return for i, a in enumerate(config_accounts): if i != idx and a["MAIL_USER"] == data["MAIL_USER"]: messagebox.showerror("Greška", "Drugi račun s ovim emailom već postoji!") return def _do(): if not _test_connection(data["IMAP_SERVER"], data["MAIL_USER"], data["MAIL_PASSWORD"]): return # Enkriptiraj / pohrani lozinku pwd = data["MAIL_PASSWORD"] if _USE_KEYRING: data.pop("MAIL_PASSWORD") _save_password(data["MAIL_USER"], pwd) else: # Fernet enkripcija ili plain text fallback data["MAIL_PASSWORD"] = _save_password(data["MAIL_USER"], pwd) with _state_lock: config_accounts[idx] = data last_unread_counts.pop(data["MAIL_USER"], None) save_config() logger.info("Račun ažuriran: %s", data["MAIL_USER"]) root.after(0, lambda: (refresh_list(), account_box.select_set(idx), lbl_status.config(text="Račun ažuriran!", fg="green"), threading.Thread(target=check_all_mails, daemon=True).start())) threading.Thread(target=_do, daemon=True).start() def on_delete(): if selected_idx[0] is None: messagebox.showerror("Greška", "Odaberi račun za brisanje!") return idx = selected_idx[0] user = config_accounts[idx]["MAIL_USER"] if not messagebox.askyesno("Potvrda", f"Obriši račun {user}?"): return with _state_lock: config_accounts.pop(idx) last_unread_counts.pop(user, None) if _USE_KEYRING: try: keyring.delete_password(KEYRING_SERVICE, user) except Exception: pass save_config() refresh_list() _clear_form() messagebox.showinfo("Uspjeh", "Račun obrisan.") threading.Thread(target=check_all_mails, daemon=True).start() # Gumbi su već dodani gore u frame_form definiciji root.mainloop() # --------------------------------------------------------------------------- # Pregled nepročitanih poruka # --------------------------------------------------------------------------- def _decode_header(raw: str) -> str: """Dekodira MIME encoded header (npr. =?UTF-8?...) u čitljiv string.""" parts = email.header.decode_header(raw or "") decoded = [] for part, charset in parts: if isinstance(part, bytes): try: decoded.append(part.decode(charset or "utf-8", errors="replace")) except Exception: decoded.append(part.decode("utf-8", errors="replace")) else: decoded.append(part) return "".join(decoded) def _fetch_messages(acc: dict, limit: int = 5) -> list[dict]: """ Dohvaća zadnjih `limit` poruka iz inboxa (sve, ne samo nepročitane). Sortira po datumu — najnovije na vrhu. Vraća listu dict-ova: {from, subject, date, unread} """ server = acc["IMAP_SERVER"] user = acc["MAIL_USER"] password = _get_password(acc) messages = [] mail_conn = None try: mail_conn = imaplib.IMAP4_SSL(server, timeout=15) mail_conn.login(user, password) mail_conn.select("inbox", readonly=True) # Dohvati sve poruke, sortirane po datumu silazno (najnovije prve) # Koristimo ALL umjesto UNSEEN status, response = mail_conn.search(None, "ALL") if status != "OK" or not response[0]: return [] all_ids = response[0].split() # Zadnjih `limit` ID-ova — IMAP vraća po redoslijedu dolaska, zadnji = najnoviji ids_to_fetch = all_ids[-limit:][::-1] # Dohvati i listu nepročitanih da možemo označiti status2, unseen_resp = mail_conn.search(None, "UNSEEN") unseen_ids = set(unseen_resp[0].split()) if status2 == "OK" else set() for msg_id in ids_to_fetch: try: status3, data = mail_conn.fetch( msg_id, "(BODY.PEEK[HEADER.FIELDS (FROM SUBJECT DATE)])" ) if status3 != "OK" or not data or not data[0]: continue raw_headers = data[0][1] msg = email.message_from_bytes(raw_headers) from_raw = msg.get("From", "") parsed_from = email.utils.parseaddr(from_raw) sender = parsed_from[0] if parsed_from[0] else parsed_from[1] sender = _decode_header(sender) or parsed_from[1] subject = _decode_header(msg.get("Subject", "(bez naslova)")) date_raw = msg.get("Date", "") try: dt = email.utils.parsedate_to_datetime(date_raw) date_str = dt.strftime("%d.%m.%Y %H:%M") except Exception: date_str = date_raw[:16] if date_raw else "?" is_unread = msg_id in unseen_ids messages.append({ "msg_id": msg_id.decode() if isinstance(msg_id, bytes) else str(msg_id), "from": sender, "subject": subject, "date": date_str, "unread": is_unread, }) except Exception as exc: logger.warning("[%s] Greška pri dohvatu poruke %s: %s", user, msg_id, exc) continue except Exception as exc: logger.error("[%s] Greška pri dohvatu poruka: %s", user, exc) finally: if mail_conn: try: mail_conn.logout() except Exception: pass return messages def _fetch_body(acc: dict, msg_id: str) -> tuple[str, str]: """ Dohvaća tijelo poruke. Označava poruku kao pročitanu. Vraća tuple (plain_text, html) — koristi što je dostupno. """ import re as _re server = acc["IMAP_SERVER"] password = _get_password(acc) mail_conn = None try: mail_conn = imaplib.IMAP4_SSL(server, timeout=15) mail_conn.login(acc["MAIL_USER"], password) mail_conn.select("inbox") status, data = mail_conn.fetch(msg_id.encode(), "(RFC822)") if status != "OK" or not data or not data[0]: return ("(Nije moguće dohvatiti sadržaj poruke)", "") raw = data[0][1] msg = email.message_from_bytes(raw) plain = "" html = "" if msg.is_multipart(): for part in msg.walk(): ct = part.get_content_type() cd = str(part.get("Content-Disposition", "")) if "attachment" in cd: continue payload = part.get_payload(decode=True) if payload is None: continue charset = part.get_content_charset() or "utf-8" decoded = payload.decode(charset, errors="replace") if ct == "text/plain" and not plain: plain = decoded elif ct == "text/html" and not html: html = decoded else: charset = msg.get_content_charset() or "utf-8" payload = msg.get_payload(decode=True) if payload: ct = msg.get_content_type() decoded = payload.decode(charset, errors="replace") if ct == "text/html": html = decoded else: plain = decoded if not plain and html: import re as _re2 # Ukloni ", "", html, flags=_re2.IGNORECASE | _re2.DOTALL) cleaned = _re2.sub(r"]*>.*?", "", cleaned, flags=_re2.IGNORECASE | _re2.DOTALL) cleaned = _re2.sub(r"]*>.*?", "", cleaned, flags=_re2.IGNORECASE | _re2.DOTALL) #
i

-> newline cleaned = _re2.sub(r"", "\n", cleaned, flags=_re2.IGNORECASE) cleaned = _re2.sub(r"

", "\n", cleaned, flags=_re2.IGNORECASE) cleaned = _re2.sub(r"", "\n", cleaned, flags=_re2.IGNORECASE) # Ukloni sve preostale HTML tagove cleaned = _re2.sub(r"<[^>]+>", "", cleaned) # Dekodira HTML entitete (&   itd.) import html as _html cleaned = _html.unescape(cleaned) # Makni višestruke prazne retke i razmake cleaned = _re2.sub(r"[ \t]+", " ", cleaned) cleaned = _re2.sub(r"\n{3,}", "\n\n", cleaned) plain = cleaned return (plain.strip() or "(Prazan sadržaj)", html) except Exception as exc: logger.error("Greška pri dohvatu tijela poruke: %s", exc) return (f"(Greška: {exc})", "") finally: if mail_conn: try: mail_conn.logout() except Exception: pass def _delete_message(acc: dict, msg_id: str) -> bool: """Premješta poruku u Trash (označava Deleted flag i expunge).""" server = acc["IMAP_SERVER"] password = _get_password(acc) mail_conn = None try: mail_conn = imaplib.IMAP4_SSL(server, timeout=15) mail_conn.login(acc["MAIL_USER"], password) mail_conn.select("inbox") # Pokušaj premjestiti u Trash (Gmail / standardni IMAP) trash_folders = ["[Gmail]/Trash", "Trash", "INBOX.Trash", "Deleted Items", "Deleted Messages"] for folder in trash_folders: try: result = mail_conn.copy(msg_id.encode(), folder) if result[0] == "OK": break except Exception: continue # Označi kao obrisano i expunge mail_conn.store(msg_id.encode(), "+FLAGS", r"\Deleted") mail_conn.expunge() return True except Exception as exc: logger.error("Greška pri brisanju poruke: %s", exc) return False finally: if mail_conn: try: mail_conn.logout() except Exception: pass try: from tkinterweb import HtmlFrame as _HtmlFrame _HAVE_HTMLFRAME = True except ImportError: _HAVE_HTMLFRAME = False logger.info("tkinterweb nije instaliran — HTML poruke prikazuju se kao plain text.") def _open_read_window(acc: dict, msg: dict, on_deleted=None): """Otvara prozor za čitanje poruke. HTML poruke prikazuje u HTML rendereru (tkinterweb), plain u Text widgetu. """ read_win = tk.Toplevel() read_win.title(f"Poruka — {msg['subject']}") read_win.geometry("860x640") read_win.resizable(True, True) # Zaglavlje hdr = tk.Frame(read_win, bd=1, relief="groove", padx=6, pady=4) hdr.pack(fill="x", padx=10, pady=(10, 4)) tk.Label(hdr, text=f"Od: {msg['from']}", anchor="w", font=("TkDefaultFont", 10)).pack(fill="x", pady=1) tk.Label(hdr, text=f"Naslov: {msg['subject']}", anchor="w", font=("TkDefaultFont", 10, "bold")).pack(fill="x", pady=1) tk.Label(hdr, text=f"Datum: {msg['date']}", anchor="w", font=("TkDefaultFont", 10)).pack(fill="x", pady=1) # Toolbar toolbar = tk.Frame(read_win) toolbar.pack(fill="x", padx=10, pady=(0, 4)) lbl_status = tk.Label(toolbar, text="Dohvaćanje sadržaja...", fg="gray") lbl_status.pack(side="left") def _do_delete(): if not messagebox.askyesno("Potvrda", "Obriši ovu poruku?", parent=read_win): return lbl_status.config(text="Brisanje...", fg="gray") def _bg(): ok = _delete_message(acc, msg["msg_id"]) def _ui(): if ok: lbl_status.config(text="Poruka obrisana.", fg="green") read_win.after(1000, read_win.destroy) if on_deleted: on_deleted() else: lbl_status.config(text="Greška pri brisanju!", fg="red") read_win.after(0, _ui) threading.Thread(target=_bg, daemon=True).start() tk.Button(toolbar, text="🗑 Obriši poruku", fg="red", command=_do_delete).pack(side="right") # Rezervirani frame za tijelo — popunit će se nakon dohvata body_frame = tk.Frame(read_win) body_frame.pack(fill="both", expand=True, padx=10, pady=(0, 10)) def _show_plain(text): """Prikaži plain text u Text widgetu.""" txt = tk.Text(body_frame, wrap="word", state="normal", font=("Monospace", 10), relief="sunken", bd=1) vsb = ttk.Scrollbar(body_frame, command=txt.yview) txt.configure(yscrollcommand=vsb.set) vsb.pack(side="right", fill="y") txt.pack(fill="both", expand=True) txt.insert("end", text) txt.configure(state="disabled") def _show_html(html_content): """Prikaži HTML u HtmlFrame (tkinterweb) ili fallback na plain.""" if _HAVE_HTMLFRAME: try: hf = _HtmlFrame(body_frame, messages_enabled=False) hf.pack(fill="both", expand=True) hf.load_html(html_content) return except Exception as exc: logger.warning("tkinterweb greška: %s — fallback na plain", exc) # Fallback: konvertiraj HTML u plain import re as _re2 import html as _html cleaned = _re2.sub(r"]*>.*?", "", html_content, flags=_re2.IGNORECASE | _re2.DOTALL) cleaned = _re2.sub(r"]*>.*?", "", cleaned, flags=_re2.IGNORECASE | _re2.DOTALL) cleaned = _re2.sub(r"]*>.*?", "", cleaned, flags=_re2.IGNORECASE | _re2.DOTALL) cleaned = _re2.sub(r"", "\n", cleaned, flags=_re2.IGNORECASE) cleaned = _re2.sub(r"

||", "\n", cleaned, flags=_re2.IGNORECASE) cleaned = _re2.sub(r"<[^>]+>", "", cleaned) cleaned = _html.unescape(cleaned) cleaned = _re2.sub(r"[ \t]+", " ", cleaned) cleaned = _re2.sub(r"\n{3,}", "\n\n", cleaned) _show_plain(cleaned.strip()) # Dohvati tijelo u backgroundu def _load_body(): plain, html = _fetch_body(acc, msg["msg_id"]) def _show(): lbl_status.config(text="") if html: # HTML mail — prikaži u HTML rendereru _show_html(html) elif plain and plain != "(Prazan sadržaj)": # Čisti plain text mail _show_plain(plain) else: _show_plain("(Prazan sadržaj)") read_win.after(0, _show) threading.Thread(target=_load_body, daemon=True).start() # Singleton referenca na prozor poruka _messages_win: list = [None] # GUI zadaci koje treba pokrenuti iz glavnog threada (tray callbacks) _pending_gui: list = [] def open_messages_window(icon=None, item=None): """Otvara prozor s pregledom poruka. Poziva se iz tray threada — koristi Toplevel.""" # Ako je prozor već otvoren, samo ga podigne na vrh if _messages_win[0] is not None: try: _messages_win[0].lift() _messages_win[0].focus_force() return except Exception: _messages_win[0] = None with _state_lock: accounts = [a for a in config_accounts if a.get("PREVIEW_ENABLED", True)] if not accounts: _send_notification("Mail Checker", "Nema računa s uključenim pregledom poruka.") return def _build_window(): # Koristimo Toplevel koji dijeli event loop s ostalim tk prozorima win = tk.Toplevel() _messages_win[0] = win win.title("Mail Checker — Pregled poruka") win.geometry("760x460") win.resizable(True, True) def _on_close(): _messages_win[0] = None win.destroy() win.protocol("WM_DELETE_WINDOW", _on_close) btn_frame = tk.Frame(win) btn_frame.pack(fill="x", padx=10, pady=(8, 0)) lbl_loading = tk.Label(btn_frame, text="", fg="gray") lbl_loading.pack(side="left") notebook = ttk.Notebook(win) notebook.pack(fill="both", expand=True, padx=10, pady=6) win.update_idletasks() # Toplevel nema eval — centriramo ručno win.update_idletasks() sw = win.winfo_screenwidth() sh = win.winfo_screenheight() ww = win.winfo_width() wh = win.winfo_height() x = (sw - ww) // 2 y = (sh - wh) // 2 win.geometry(f"+{x}+{y}") def _build_tab(name, messages, acc_ref): """Kreira jedan tab — poziva se iz glavnog threada.""" frame = tk.Frame(notebook) notebook.add(frame, text=f" {name} ") cols = ("status", "from", "subject", "date") tree = ttk.Treeview(frame, columns=cols, show="headings", height=12) tree.heading("status", text="") tree.heading("from", text="Pošiljatelj") tree.heading("subject", text="Naslov") tree.heading("date", text="Datum") tree.column("status", width=22, anchor="center", stretch=False) tree.column("from", width=200, anchor="w") tree.column("subject", width=320, anchor="w") tree.column("date", width=130, anchor="center") tree.tag_configure("unread", font=("TkDefaultFont", 9, "bold")) vsb = ttk.Scrollbar(frame, orient="vertical", command=tree.yview) tree.configure(yscrollcommand=vsb.set) # Donji frame s gumbima action_frame = tk.Frame(frame) action_frame.pack(side="bottom", fill="x", pady=4) # Pohrani poruke po iid za brzi lookup msg_map = {} if messages: for m in messages: marker = "●" if m["unread"] else "" tags = ("unread",) if m["unread"] else () iid = tree.insert("", "end", values=(marker, m["from"], m["subject"], m["date"]), tags=tags) msg_map[iid] = m else: tree.insert("", "end", values=("", "—", "Nema poruka", "—")) tree.pack(side="left", fill="both", expand=True) vsb.pack(side="right", fill="y") def _get_selected_msg(): sel = tree.selection() if not sel: return None return msg_map.get(sel[0]) def _on_double_click(event): m = _get_selected_msg() if m and "msg_id" in m: _open_read_window(acc_ref, m, on_deleted=lambda: win.after( 0, lambda: threading.Thread(target=_do_refresh, daemon=True).start())) def _on_delete_btn(): m = _get_selected_msg() if not m or "msg_id" not in m: messagebox.showwarning("Upozorenje", "Odaberi poruku za brisanje.", parent=win) return if not messagebox.askyesno("Potvrda", "Obriši ovu poruku?", parent=win): return def _bg(): ok = _delete_message(acc_ref, m["msg_id"]) if ok: win.after(0, lambda: threading.Thread( target=_do_refresh, daemon=True).start()) else: win.after(0, lambda: messagebox.showerror( "Greška", "Brisanje nije uspjelo.", parent=win)) threading.Thread(target=_bg, daemon=True).start() tree.bind("", _on_double_click) tk.Button(action_frame, text="📖 Čitaj poruku", width=16, command=lambda: _on_double_click(None)).pack(side="left", padx=8) tk.Button(action_frame, text="🗑 Obriši", width=12, fg="red", command=_on_delete_btn).pack(side="left", padx=4) def _do_refresh(): """Background thread: dohvati podatke pa ažuriraj GUI kroz win.after.""" with _state_lock: accs = [a for a in config_accounts if a.get("PREVIEW_ENABLED", True)] win.after(0, lambda: lbl_loading.config(text="Dohvaćanje poruka...", fg="gray")) results = [] for acc in accs: name = acc.get("NICKNAME") or acc["MAIL_USER"].split("@")[0] limit = acc.get("PREVIEW_COUNT", 5) msgs = _fetch_messages(acc, limit=limit) results.append((name, msgs, acc)) logger.info("Dohvaćeno %d poruka za %s", len(msgs), name) def _finish_ui(): # Očisti stare tabove for tab in notebook.tabs(): notebook.forget(tab) # Dodaj nove for name, msgs, acc_ref in results: _build_tab(name, msgs, acc_ref) lbl_loading.config(text=f"Zadnje osvježavanje: {time.strftime('%H:%M:%S')}", fg="gray") win.after(0, _finish_ui) tk.Button( btn_frame, text="↻ Osvježi", width=10, command=lambda: threading.Thread(target=_do_refresh, daemon=True).start() ).pack(side="right") # Pokretanje prvog dohvata threading.Thread(target=_do_refresh, daemon=True).start() # Ubaci u pending queue — glavna petlja (setup_tray) će pokrenuti u pravom threadu _pending_gui.append(_build_window) # --------------------------------------------------------------------------- # Tray setup i main # --------------------------------------------------------------------------- def show_status(icon=None, item=None): """Prikazuje notifikaciju s brojem nepročitanih po svakom računu.""" with _state_lock: counts = dict(last_unread_counts) accounts = list(config_accounts) if not accounts: _send_notification("Mail Checker", "Nema konfiguriranih računa.") return lines = [] total = 0 for acc in accounts: user = acc["MAIL_USER"] name = acc.get("NICKNAME") or user.split("@")[0] count = counts.get(user) if count is None: lines.append(f"{name}: još nije provjereno") elif count == 0: lines.append(f"{name}: inbox čist") else: word = get_croatian_mail_word(count) lines.append(f"{name}: {count} {word}") total += count body = "\n".join(lines) title = f"Mail Checker — ukupno: {total}" if total > 0 else "Mail Checker — inbox čist" _send_notification(title, body) def setup_tray(): global tray_icon menu = pystray.Menu( pystray.MenuItem("Provjeri odmah", lambda: threading.Thread( target=check_all_mails, daemon=True).start()), pystray.MenuItem("Status", show_status), pystray.MenuItem("Pregled poruka", open_messages_window), pystray.MenuItem("Postavke", show_settings_from_tray), pystray.MenuItem("Izlaz", on_exit), ) load_config() color = "blue" if config_accounts else "gray" title = "Mail Checker" if config_accounts else "Mail Checker: Nema konfiguriranih računa" tray_icon = pystray.Icon("mail_checker", create_icon_image(color), title, menu) checker_thread = threading.Thread(target=background_loop, daemon=True) checker_thread.start() if not config_accounts: threading.Thread(target=open_settings_window, daemon=True).start() def _process_pending(): """Procesira GUI zadatke zahtijevane iz tray threada.""" while _pending_gui: fn = _pending_gui.pop(0) try: fn() except Exception as exc: logger.error("Greška pri pokretanju GUI zadatka: %s", exc) def _run_tray_with_gui_pump(): """Pokreće tray u zasebnom threadu, a glavni thread pumpuje GUI zadatke.""" tray_thread = threading.Thread(target=tray_icon.run, daemon=True) tray_thread.start() # Drži glavni thread živ i procesira pending GUI zadatke import tkinter as _tk root = _tk.Tk() root.withdraw() # nevidljiv root — samo drži event loop živ def _pump(): _process_pending() if is_running: root.after(200, _pump) else: root.destroy() root.after(200, _pump) try: root.mainloop() except Exception: pass try: _run_tray_with_gui_pump() except Exception as exc: logger.critical("Tray ikona se srušila: %s", exc) if __name__ == "__main__": setup_tray()