TrackerApp

# src/db.py
from sqlalchemy import event, inspect
from sqlalchemy.orm import Session
import json
from src.models.system import AuditLog

def log_change(session, action, target):
    """Przygotowuje wpis audytu. Dla INSERT ID zostanie uzupełnione w after_flush."""
    if isinstance(target, AuditLog):
        return

    table_name = target.__tablename__
    current_user = get_current_user()

    state = inspect(target)
    old_values = {}
    new_values = {}

    if action == 'UPDATE':
        for attr in state.mapper.column_attrs:
            hist = state.get_history(attr.key, True)
            if hist.has_changes():
                if hist.deleted:
                    old_values[attr.key] = str(hist.deleted[0]) if hist.deleted[0] is not None else None
                new_values[attr.key] = str(getattr(target, attr.key))
    elif action == 'INSERT':
        new_values = {k: str(v) if v is not None else None for k, v in object_as_dict(target).items()}
    elif action == 'DELETE':
        old_values = {k: str(v) if v is not None else None for k, v in object_as_dict(target).items()}

    def truncate_large_data(data_dict):
        """Skraca zbyt długie wartości w słowniku logów."""
        if not data_dict:
            return None
        truncated = {}
        for k, v in data_dict.items():
            if v and len(v) > 1000:
                truncated[k] = f"{v[:100]}... <TRUNCATED {len(v)} chars> ...{v[-20:]}"
            else:
                truncated[k] = v
        return json.dumps(truncated)

    audit_entry = AuditLog(
        TableName=table_name,
        RecordID=getattr(target, 'ID', None),
        Action=action,
        OldValues=truncate_large_data(old_values),
        NewValues=truncate_large_data(new_values),
        User=current_user
    )
    audit_entry._target_obj = target

    if not hasattr(session, '_pending_audit_logs'):
        session._pending_audit_logs = []
    session._pending_audit_logs.append(audit_entry)

@event.listens_for(Session, 'before_flush')
def receive_before_flush(session, flush_context, instances):
    for obj in session.new:
        log_change(session, 'INSERT', obj)
    for obj in session.dirty:
        if session.is_modified(obj):
            log_change(session, 'UPDATE', obj)
    for obj in session.deleted:
        log_change(session, 'DELETE', obj)

@event.listens_for(Session, 'after_flush')
def audit_after_flush(session, flush_context):
    """Uzupełnia RecordID dla nowych obiektów i zapisuje logi audytu."""
    if not hasattr(session, '_pending_audit_logs') or not session._pending_audit_logs:
        return

    logs = session._pending_audit_logs
    session._pending_audit_logs = []

    for log in logs:
        if log.Action == 'INSERT' and log.RecordID is None:
            log.RecordID = getattr(log._target_obj, 'ID', None)
            if log.NewValues and log.RecordID is not None:
                try:
                    if log.NewValues.strip().startswith("{") and "<TRUNCATED" not in log.NewValues:
                        nv = json.loads(log.NewValues)
                        if 'ID' in nv and (nv['ID'] is None or nv['ID'] == 'None'):
                            nv['ID'] = str(log.RecordID)
                            log.NewValues = json.dumps(nv)
                except: pass
        if hasattr(log, '_target_obj'):
            del log._target_obj
        session.add(log)

# src/printer_godex.py
import socket
import win32print

# Komunikacja sieciowa przez surowe gniazdo TCP/IP
class Ge300LAN(PrinterFlash):
    def connect_to_printer(self):
        self.__check_connection_detail()
        try:
            self.__printer = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.__printer.settimeout(2)
            self.__printer.connect((self.__printer_ip, self.__tcp_port))
        except Exception as e:
            self.logs.add_log("w", f"Błąd połączenia TCP/IP z drukarką: {e}")

    def send_to_printer(self, label, **kwargs):
        self.connect_to_printer()
        if not self.__printer:
            return
        raw_data = bytes(label, "utf-8")
        try:
            self.__printer.send(raw_data)
        except Exception as e:
            self.logs.add_log("w", f"Błąd wysyłania komend ezPL: {e}")
        finally:
            self.__printer.close()

# Komunikacja USB z pominięciem sterowników przez low-level Windows API
class Ge300USB(PrinterFlash):
    def connect_to_printer(self):
        self.__check_connection_detail()
        try:
            self.__printer = win32print.OpenPrinter(self.__printer_name)
            # Sprawdzenie statusu online/offline drukarki
            attributes = win32print.GetPrinter(self.__printer)[13]
            if (attributes & 0x00000400) >> 10:
                self.__printer = None
                self.logs.add_log("w", "Drukarka USB jest offline!")
        except Exception as e:
            self.logs.add_log("w", f"Błąd otwierania portu drukarki USB: {e}")

    def send_to_printer(self, label, **kwargs):
        self.connect_to_printer()
        if not self.__printer:
            return
        raw_data = bytes(label, "utf-8")
        try:
            hJob = win32print.StartDocPrinter(self.__printer, 1, ("TrackerApp - label", None, "RAW"))
            try:
                win32print.StartPagePrinter(self.__printer)
                win32print.WritePrinter(self.__printer, raw_data)
                win32print.EndPagePrinter(self.__printer)
            finally:
                win32print.EndDocPrinter(self.__printer)
        finally:
            win32print.ClosePrinter(self.__printer)

# src/reports_generator/worker.py
from PyQt6.QtCore import QThread, pyqtSignal

class ReportsGeneratorWorker(QThread):
    finished = pyqtSignal(str)  # Sygnał po sukcesie (SN urządzenia)
    error = pyqtSignal(str)     # Sygnał błędu
    progress = pyqtSignal(str)   # Sygnał ze statusem postępu (tekst)

    def __init__(self, sn: str, destination_path: str, product_report_builder):
        super().__init__()
        self.sn = sn
        self.destination_path = destination_path
        self.builder = product_report_builder  # Obiekt generatora PDF (ProductReport)

    def run(self):
        try:
            self.progress.emit("Zbieranie danych z baz danych...")
            data = self.builder._collect_product_data_internal(self.sn, self.destination_path)
            if not data:
                self.error.emit("Nie udało się zebrać danych dla podanego numeru SN.")
                return

            self.progress.emit("Budowanie dokumentu PDF...")
            self.builder._setup_document(data)
            self.builder._build_report_content(data)

            self.progress.emit("Finalizacja i zapisywanie...")
            self.builder._finalize_report_internal(data['product'])

            self.finished.emit(self.sn)
        except Exception as e:
            self.error.emit(f"Błąd krytyczny podczas generowania raportu: {str(e)}")