246 lines
7.9 KiB
Python
246 lines
7.9 KiB
Python
import os
|
|
import sys
|
|
import time
|
|
import requests
|
|
from datetime import datetime, timedelta
|
|
import fitz # PyMuPDF
|
|
import win32print
|
|
import win32ui
|
|
from PIL import Image, ImageWin
|
|
import winreg # ← Registry-Zugriff
|
|
os.system("chcp 65001")
|
|
|
|
# Registry-Pfad
|
|
REG_PATH = r"Software\PDFExporter"
|
|
|
|
# Registry-Funktion zum Lesen
|
|
def read_registry_value(name):
|
|
try:
|
|
key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, REG_PATH, 0, winreg.KEY_READ)
|
|
value, _ = winreg.QueryValueEx(key, name)
|
|
winreg.CloseKey(key)
|
|
return value
|
|
except FileNotFoundError:
|
|
return None
|
|
|
|
# Werte aus Registry lesen
|
|
url = read_registry_value("Server")
|
|
api_key = read_registry_value("APIKey")
|
|
label_printer = read_registry_value("LabelPrinter")
|
|
order_printer = read_registry_value("OrderPrinter")
|
|
|
|
if not all([url, label_printer, order_printer]):
|
|
print("Fehlende Konfiguration in der Registry! Bitte zuerst Konfiguration über die GUI durchführen.")
|
|
sys.exit(1)
|
|
|
|
# Log-Dateipfad
|
|
log_dir = "logs"
|
|
os.makedirs(log_dir, exist_ok=True)
|
|
|
|
def get_log_filename():
|
|
"""Erstellt einen Dateinamen für das Log basierend auf dem aktuellen Datum."""
|
|
return os.path.join(log_dir, f"{datetime.now().strftime('%Y-%m-%d')}.log")
|
|
|
|
def setup_logging():
|
|
"""Erstellt eine Log-Datei und löscht alte Log-Dateien, die älter als 7 Tage sind."""
|
|
# Logdatei für den aktuellen Tag
|
|
log_file = get_log_filename()
|
|
|
|
# Log-Datei öffnen
|
|
sys.stdout = open(log_file, 'a')
|
|
sys.stderr = sys.stdout
|
|
|
|
# Alte Log-Dateien löschen (älter als 7 Tage)
|
|
delete_old_logs()
|
|
|
|
def delete_old_logs():
|
|
"""Löscht Log-Dateien, die älter als 7 Tage sind."""
|
|
for filename in os.listdir(log_dir):
|
|
file_path = os.path.join(log_dir, filename)
|
|
if os.path.isfile(file_path):
|
|
file_age = datetime.now() - datetime.fromtimestamp(os.path.getmtime(file_path))
|
|
if file_age > timedelta(days=7):
|
|
os.remove(file_path)
|
|
print(f"Altes Log gelöscht: {filename}")
|
|
|
|
def log_message(message):
|
|
"""Schreibt eine Nachricht ins Log."""
|
|
print(f"{datetime.now().strftime('%Y-%m-%d %H:%M:%S')} - {message}")
|
|
|
|
# Verbesserte Druckfunktion
|
|
def print_pdf(file_path, printer_name):
|
|
if not os.path.exists(file_path):
|
|
log_message(f'Datei nicht gefunden: {file_path}')
|
|
return False
|
|
|
|
try:
|
|
hprinter = win32print.OpenPrinter(printer_name)
|
|
hdc = win32ui.CreateDC()
|
|
hdc.CreatePrinterDC(printer_name)
|
|
hdc.StartDoc(file_path)
|
|
|
|
pdf_document = fitz.open(file_path)
|
|
printer_size = hdc.GetDeviceCaps(8), hdc.GetDeviceCaps(10) # Horizontale/Vertikale Größe in Pixel
|
|
|
|
for page_number in range(len(pdf_document)):
|
|
page = pdf_document.load_page(page_number)
|
|
|
|
zoom = 3.0
|
|
mat = fitz.Matrix(zoom, zoom)
|
|
pix = page.get_pixmap(matrix=mat, alpha=False)
|
|
|
|
image = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
|
|
dib = ImageWin.Dib(image)
|
|
|
|
scale_x = printer_size[0] / pix.width
|
|
scale_y = printer_size[1] / pix.height
|
|
scale = min(scale_x, scale_y)
|
|
|
|
x_pos = int((printer_size[0] - (pix.width * scale)) // 2)
|
|
y_pos = int((printer_size[1] - (pix.height * scale)) // 2)
|
|
width = int(pix.width * scale)
|
|
height = int(pix.height * scale)
|
|
|
|
hdc.StartPage()
|
|
try:
|
|
dib.draw(hdc.GetHandleOutput(), (x_pos, y_pos, x_pos + width, y_pos + height))
|
|
except Exception as draw_error:
|
|
log_message(f"Zeichenfehler: {draw_error}")
|
|
dib.draw(hdc.GetHandleOutput(), (0, 0, printer_size[0], printer_size[1]))
|
|
hdc.EndPage()
|
|
|
|
hdc.EndDoc()
|
|
hdc.DeleteDC()
|
|
win32print.ClosePrinter(hprinter)
|
|
log_message(f"Erfolgreich gedruckt: {file_path}")
|
|
return True
|
|
|
|
except Exception as e:
|
|
log_message(f"Fehler beim Drucken von {file_path}: {str(e)}")
|
|
import traceback
|
|
traceback.print_exc()
|
|
return False
|
|
|
|
# Debug-Funktion aktivieren
|
|
setup_logging()
|
|
|
|
# Einzeldatei-Druck prüfen
|
|
if len(sys.argv) > 1:
|
|
file_to_print = sys.argv[1]
|
|
|
|
if "label" in file_to_print.lower():
|
|
printer = label_printer
|
|
else:
|
|
printer = order_printer
|
|
|
|
log_message(f"Einzeldatei-Modus: {file_to_print} - {printer}")
|
|
print_pdf(file_to_print, printer)
|
|
sys.exit(0)
|
|
|
|
# KEIN Dateiname angegeben → Standard-Workflow (Download, Aufteilen, Drucken)
|
|
|
|
# Zeitstempel für die Dateien
|
|
timestamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
|
|
|
|
# Pfad der Dateien
|
|
original_storage_path = "./original"
|
|
order_storage_path = "./orders"
|
|
label_storage_path = "./label"
|
|
|
|
# Verzeichnisse erstellen
|
|
os.makedirs(original_storage_path, exist_ok=True)
|
|
os.makedirs(order_storage_path, exist_ok=True)
|
|
os.makedirs(label_storage_path, exist_ok=True)
|
|
|
|
# PDF von der API herunterladen
|
|
if url:
|
|
response = requests.get(url)
|
|
if response.status_code == 200:
|
|
file_name = f'{original_storage_path}/original_{timestamp}.pdf'
|
|
with open(file_name, 'wb') as file:
|
|
file.write(response.content)
|
|
log_message(f'PDF erfolgreich heruntergeladen: "{file_name}"')
|
|
else:
|
|
log_message(f'Fehler beim Herunterladen. Statuscode: {response.status_code}')
|
|
exit(1)
|
|
else:
|
|
log_message('API-URL nicht in .env gefunden.')
|
|
exit(1)
|
|
|
|
# Dokument verarbeiten
|
|
doc = fitz.open(f'{original_storage_path}/original_{timestamp}.pdf')
|
|
|
|
label_sections = {}
|
|
current_label = None
|
|
start_page = None
|
|
order_end_page = None
|
|
|
|
markers = {
|
|
"########## DHL LABELS ##########": "DHL",
|
|
"########## DPD LABELS ##########": "DPD",
|
|
"########## UPS LABELS ##########": "UPS"
|
|
}
|
|
|
|
# Dokument in Abschnitte teilen
|
|
for page_number in range(len(doc)):
|
|
page = doc.load_page(page_number)
|
|
text = page.get_text()
|
|
|
|
found_label = None
|
|
for marker_text, label_name in markers.items():
|
|
if marker_text in text:
|
|
found_label = label_name
|
|
break
|
|
|
|
if found_label:
|
|
if current_label is None:
|
|
order_end_page = page_number - 1
|
|
|
|
if current_label is not None and start_page is not None:
|
|
section_doc = fitz.open()
|
|
section_doc.insert_pdf(doc, from_page=start_page, to_page=page_number - 1)
|
|
label_sections.setdefault(current_label, []).append(section_doc)
|
|
|
|
current_label = found_label
|
|
start_page = page_number + 1
|
|
|
|
# Letzten Abschnitt speichern
|
|
if current_label is not None and start_page is not None and start_page < len(doc):
|
|
section_doc = fitz.open()
|
|
section_doc.insert_pdf(doc, from_page=start_page, to_page=len(doc) - 1)
|
|
label_sections.setdefault(current_label, []).append(section_doc)
|
|
|
|
# Bestellung speichern
|
|
if order_end_page is not None and order_end_page >= 0:
|
|
order_doc = fitz.open()
|
|
order_doc.insert_pdf(doc, from_page=0, to_page=order_end_page)
|
|
order_filename = f"{order_storage_path}/order_{timestamp}.pdf"
|
|
order_doc.save(order_filename)
|
|
log_message(f"Bestellung gespeichert als {order_filename}")
|
|
|
|
# Labels speichern
|
|
for label, docs in label_sections.items():
|
|
for idx, pdf in enumerate(docs, start=1):
|
|
filename = f"{label_storage_path}/{label}_label_{idx}_{timestamp}.pdf"
|
|
pdf.save(filename)
|
|
log_message(f"{label} Label gespeichert als {filename}")
|
|
|
|
# Druckvorgang
|
|
log_message("\nStarte Druckvorgang:")
|
|
|
|
# Labels drucken
|
|
for label in label_sections:
|
|
for idx, pdf in enumerate(label_sections[label], start=1):
|
|
label_filename = f"{label_storage_path}/{label}_label_{idx}_{timestamp}.pdf"
|
|
log_message(f"Drucke {label} Label {idx}...")
|
|
print_pdf(label_filename, label_printer)
|
|
time.sleep(1) # Kurze Pause zwischen den Druckaufträgen
|
|
|
|
# Bestellung drucken
|
|
if order_end_page is not None:
|
|
log_message("\nDrucke Bestellung...")
|
|
order_filename = f"{order_storage_path}/order_{timestamp}.pdf"
|
|
print_pdf(order_filename, order_printer)
|
|
|
|
log_message("\nDruckvorgang abgeschlossen.")
|