855 lines
32 KiB
Java
855 lines
32 KiB
Java
import de.vertico.starface.module.core.model.VariableType;
|
|
import de.vertico.starface.module.core.model.Visibility;
|
|
import de.vertico.starface.module.core.runtime.IBaseExecutable;
|
|
import de.vertico.starface.module.core.runtime.IRuntimeEnvironment;
|
|
import de.vertico.starface.module.core.runtime.annotations.Function;
|
|
import de.vertico.starface.module.core.runtime.annotations.InputVar;
|
|
import de.vertico.starface.module.core.runtime.annotations.OutputVar;
|
|
|
|
import javax.mail.*;
|
|
import javax.mail.internet.MimeBodyPart;
|
|
import javax.mail.search.FlagTerm;
|
|
import java.io.*;
|
|
import java.nio.file.*;
|
|
import java.util.*;
|
|
import java.util.concurrent.locks.ReentrantLock;
|
|
|
|
/**
|
|
* Mail2FaxBlock - STARFACE Custom Block
|
|
*
|
|
* Ruft E-Mails ab und sendet PDF-Anhänge als Fax.
|
|
* Die Ziel-Faxnummer wird aus dem E-Mail-Betreff gelesen.
|
|
*
|
|
* Für STARFACE 8.x, 9.x, 10.x (Java 21)
|
|
*/
|
|
@Function(
|
|
visibility = Visibility.Private,
|
|
description = "Ruft E-Mails ab und sendet PDF-Anhänge als Fax"
|
|
)
|
|
public class Mail2FaxBlock implements IBaseExecutable {
|
|
|
|
// Fax result constants (instead of inner class to avoid separate .class file)
|
|
private static final int FAX_SUCCESS = 0;
|
|
private static final int FAX_RETRY = 1;
|
|
private static final int FAX_FAIL = 2;
|
|
|
|
// Lock um parallele Ausführung zu verhindern
|
|
private static final ReentrantLock executionLock = new ReentrantLock();
|
|
|
|
// Pfade für Tracking-Dateien
|
|
private static final String DATA_DIR = "/var/starface/module-data";
|
|
private static final String PROCESSED_FILE = DATA_DIR + "/mail2fax_processed.txt";
|
|
private static final String RETRY_FILE = DATA_DIR + "/mail2fax_retry.txt";
|
|
|
|
// ============================================================
|
|
// INPUT VARIABLEN - werden im Module Designer konfiguriert
|
|
// ============================================================
|
|
|
|
@InputVar(
|
|
label = "Mail Server",
|
|
description = "IMAP oder POP3 Server Adresse",
|
|
type = VariableType.STRING
|
|
)
|
|
public String mailServer = "";
|
|
|
|
@InputVar(
|
|
label = "Mail Port",
|
|
description = "Server Port (993 für IMAPS, 995 für POP3S, 143 für IMAP, 110 für POP3)",
|
|
type = VariableType.NUMBER
|
|
)
|
|
public Integer mailPort = 993;
|
|
|
|
@InputVar(
|
|
label = "Protokoll",
|
|
description = "IMAP oder POP3",
|
|
type = VariableType.STRING
|
|
)
|
|
public String mailProtocol = "IMAP";
|
|
|
|
@InputVar(
|
|
label = "Benutzername",
|
|
description = "E-Mail Benutzername",
|
|
type = VariableType.STRING
|
|
)
|
|
public String mailUsername = "";
|
|
|
|
@InputVar(
|
|
label = "Passwort",
|
|
description = "E-Mail Passwort",
|
|
type = VariableType.STRING
|
|
)
|
|
public String mailPassword = "";
|
|
|
|
@InputVar(
|
|
label = "SSL verwenden",
|
|
description = "SSL/TLS für die Verbindung aktivieren",
|
|
type = VariableType.BOOLEAN
|
|
)
|
|
public Boolean mailUseSsl = true;
|
|
|
|
@InputVar(
|
|
label = "Ordner",
|
|
description = "E-Mail Ordner (Standard: INBOX)",
|
|
type = VariableType.STRING
|
|
)
|
|
public String mailFolder = "INBOX";
|
|
|
|
@InputVar(
|
|
label = "Nach Verarbeitung löschen",
|
|
description = "E-Mails nach erfolgreicher Verarbeitung löschen (nur IMAP, bei POP3 werden E-Mails immer nach erfolgreichem Versand gelöscht)",
|
|
type = VariableType.BOOLEAN
|
|
)
|
|
public Boolean deleteAfterProcess = false;
|
|
|
|
@InputVar(
|
|
label = "Fax-Benutzer",
|
|
description = "STARFACE Benutzer für den Fax-Versand (muss Fax-Berechtigung haben)",
|
|
type = VariableType.STARFACE_USER
|
|
)
|
|
public Integer faxAccountId = 0;
|
|
|
|
@InputVar(
|
|
label = "Absender-Faxnummer",
|
|
description = "Ausgehende Faxnummer (z.B. +49721123456)",
|
|
type = VariableType.STRING
|
|
)
|
|
public String faxSenderNumber = "";
|
|
|
|
@InputVar(
|
|
label = "Erlaubte Absender",
|
|
description = "Komma-getrennte Liste erlaubter Absender-Adressen (leer = alle erlaubt)",
|
|
type = VariableType.STRING
|
|
)
|
|
public String authorizedSenders = "";
|
|
|
|
@InputVar(
|
|
label = "Betreff-Präfix",
|
|
description = "Präfix im Betreff (optional). Wenn gesetzt, muss der Betreff mit diesem Präfix beginnen (z.B. 'FAXMaik:'). Ermöglicht Filter-Regeln im E-Mail-Client für mehrere Fax-Instanzen.",
|
|
type = VariableType.STRING
|
|
)
|
|
public String subjectPrefix = "";
|
|
|
|
@InputVar(
|
|
label = "PIN",
|
|
description = "Sicherheits-PIN (optional). Wenn gesetzt, muss die PIN im E-Mail-Text enthalten sein um das Fax zu senden.",
|
|
type = VariableType.STRING
|
|
)
|
|
public String pin = "";
|
|
|
|
@InputVar(
|
|
label = "Max. Wiederholungen",
|
|
description = "Maximale Anzahl Wiederholungsversuche bei besetzter Leitung",
|
|
type = VariableType.NUMBER
|
|
)
|
|
public Integer maxRetries = 3;
|
|
|
|
@InputVar(
|
|
label = "Wartezeit (Minuten)",
|
|
description = "Minuten zwischen Wiederholungsversuchen",
|
|
type = VariableType.NUMBER
|
|
)
|
|
public Integer retryDelayMinutes = 5;
|
|
|
|
// ============================================================
|
|
// OUTPUT VARIABLEN - Ergebnisse der Ausführung
|
|
// ============================================================
|
|
|
|
@OutputVar(
|
|
label = "Verarbeitete E-Mails",
|
|
description = "Anzahl der verarbeiteten E-Mails",
|
|
type = VariableType.NUMBER
|
|
)
|
|
public Integer processedCount = 0;
|
|
|
|
@OutputVar(
|
|
label = "Gesendete Faxe",
|
|
description = "Anzahl erfolgreich gesendeter Faxe",
|
|
type = VariableType.NUMBER
|
|
)
|
|
public Integer sentFaxCount = 0;
|
|
|
|
@OutputVar(
|
|
label = "Fehleranzahl",
|
|
description = "Anzahl der Fehler",
|
|
type = VariableType.NUMBER
|
|
)
|
|
public Integer errorCount = 0;
|
|
|
|
@OutputVar(
|
|
label = "Wartende Wiederholungen",
|
|
description = "Anzahl der Faxe die auf Wiederholung warten",
|
|
type = VariableType.NUMBER
|
|
)
|
|
public Integer pendingRetries = 0;
|
|
|
|
@OutputVar(
|
|
label = "Status",
|
|
description = "Status-Meldung der letzten Ausführung",
|
|
type = VariableType.STRING
|
|
)
|
|
public String statusMessage = "";
|
|
|
|
// Runtime Environment
|
|
private IRuntimeEnvironment runtime;
|
|
private org.apache.logging.log4j.Logger log;
|
|
|
|
@Override
|
|
public void execute(IRuntimeEnvironment runtime) throws Exception {
|
|
this.runtime = runtime;
|
|
this.log = runtime.getLog();
|
|
|
|
// Pflichtfelder validieren
|
|
List<String> missingFields = new ArrayList<>();
|
|
|
|
if (mailServer == null || mailServer.trim().isEmpty()) {
|
|
missingFields.add("mailServer (Mail Server)");
|
|
}
|
|
if (mailPort == null || mailPort <= 0) {
|
|
missingFields.add("mailPort (Port)");
|
|
}
|
|
if (mailUsername == null || mailUsername.trim().isEmpty()) {
|
|
missingFields.add("mailUsername (Benutzername)");
|
|
}
|
|
if (mailPassword == null || mailPassword.trim().isEmpty()) {
|
|
missingFields.add("mailPassword (Passwort)");
|
|
}
|
|
if (faxAccountId == null || faxAccountId <= 0) {
|
|
missingFields.add("faxAccountId (Fax-Benutzer)");
|
|
}
|
|
if (faxSenderNumber == null || faxSenderNumber.trim().isEmpty()) {
|
|
missingFields.add("faxSenderNumber (Absender-Faxnummer)");
|
|
}
|
|
|
|
if (!missingFields.isEmpty()) {
|
|
statusMessage = "Konfigurationsfehler: Pflichtfelder nicht ausgefüllt";
|
|
log.error("Mail2Fax: " + statusMessage + ": " + String.join(", ", missingFields));
|
|
return;
|
|
}
|
|
|
|
// Versuche Lock zu bekommen - wenn nicht verfügbar, läuft bereits eine Instanz
|
|
if (!executionLock.tryLock()) {
|
|
log.info("Mail2Fax: Bereits eine Instanz aktiv, überspringe Ausführung");
|
|
statusMessage = "Übersprungen - bereits aktiv";
|
|
return;
|
|
}
|
|
|
|
try {
|
|
log.info("Mail2Fax: Starte E-Mail-Abruf von " + mailServer);
|
|
|
|
// Datenverzeichnis erstellen
|
|
Files.createDirectories(Paths.get(DATA_DIR));
|
|
|
|
// Zuerst Retry-Queue verarbeiten
|
|
processRetryQueue();
|
|
|
|
// Dann neue E-Mails abrufen
|
|
fetchAndProcessEmails();
|
|
|
|
statusMessage = String.format(
|
|
"Fertig: %d E-Mails verarbeitet, %d Faxe gesendet, %d Fehler, %d warten auf Retry",
|
|
processedCount, sentFaxCount, errorCount, pendingRetries
|
|
);
|
|
log.info("Mail2Fax: " + statusMessage);
|
|
|
|
} finally {
|
|
executionLock.unlock();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verarbeitet die Retry-Queue für fehlgeschlagene Faxe
|
|
*/
|
|
private void processRetryQueue() {
|
|
try {
|
|
Path retryPath = Paths.get(RETRY_FILE);
|
|
if (!Files.exists(retryPath)) {
|
|
return;
|
|
}
|
|
|
|
List<String> lines = Files.readAllLines(retryPath);
|
|
List<String> remaining = new ArrayList<>();
|
|
long now = System.currentTimeMillis();
|
|
|
|
for (String line : lines) {
|
|
if (line.trim().isEmpty()) continue;
|
|
|
|
// Format: timestamp|retryCount|destination|senderNumber|pdfPath|messageId
|
|
String[] parts = line.split("\\|", 6);
|
|
if (parts.length < 6) continue;
|
|
|
|
long scheduledTime = Long.parseLong(parts[0]);
|
|
int retryCount = Integer.parseInt(parts[1]);
|
|
String destination = parts[2];
|
|
String senderNumber = parts[3];
|
|
String pdfPath = parts[4];
|
|
String messageId = parts[5];
|
|
|
|
if (now < scheduledTime) {
|
|
// Noch nicht Zeit für Retry
|
|
remaining.add(line);
|
|
pendingRetries++;
|
|
continue;
|
|
}
|
|
|
|
// Retry durchführen
|
|
File pdfFile = new File(pdfPath);
|
|
if (!pdfFile.exists()) {
|
|
log.warn("Mail2Fax: Retry-PDF nicht mehr vorhanden: " + pdfPath);
|
|
continue;
|
|
}
|
|
|
|
log.info("Mail2Fax: Retry #" + retryCount + " für " + destination);
|
|
int result = sendFax(destination, senderNumber, pdfFile);
|
|
|
|
if (result == FAX_SUCCESS) {
|
|
sentFaxCount++;
|
|
pdfFile.delete(); // Temp-Datei löschen
|
|
markAsProcessed(messageId);
|
|
} else if (result == FAX_RETRY && retryCount < maxRetries) {
|
|
// Erneut in Queue
|
|
long nextRetry = now + (retryDelayMinutes * 60 * 1000L);
|
|
remaining.add(nextRetry + "|" + (retryCount + 1) + "|" + destination + "|" +
|
|
senderNumber + "|" + pdfPath + "|" + messageId);
|
|
pendingRetries++;
|
|
} else {
|
|
log.error("Mail2Fax: Endgültig fehlgeschlagen nach " + retryCount + " Versuchen: " + destination);
|
|
errorCount++;
|
|
pdfFile.delete();
|
|
}
|
|
}
|
|
|
|
// Aktualisierte Queue speichern
|
|
Files.write(retryPath, remaining);
|
|
|
|
} catch (Exception e) {
|
|
log.error("Mail2Fax: Fehler bei Retry-Queue: " + e.getMessage(), e);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ruft E-Mails ab und verarbeitet sie
|
|
*/
|
|
private void fetchAndProcessEmails() {
|
|
Store store = null;
|
|
Folder folder = null;
|
|
|
|
try {
|
|
// Session konfigurieren
|
|
Properties props = new Properties();
|
|
String protocol = mailProtocol.toUpperCase();
|
|
|
|
if (protocol.equals("IMAP")) {
|
|
if (mailUseSsl) {
|
|
props.put("mail.store.protocol", "imaps");
|
|
props.put("mail.imaps.host", mailServer);
|
|
props.put("mail.imaps.port", String.valueOf(mailPort));
|
|
props.put("mail.imaps.ssl.enable", "true");
|
|
} else {
|
|
props.put("mail.store.protocol", "imap");
|
|
props.put("mail.imap.host", mailServer);
|
|
props.put("mail.imap.port", String.valueOf(mailPort));
|
|
}
|
|
} else { // POP3
|
|
if (mailUseSsl) {
|
|
props.put("mail.store.protocol", "pop3s");
|
|
props.put("mail.pop3s.host", mailServer);
|
|
props.put("mail.pop3s.port", String.valueOf(mailPort));
|
|
props.put("mail.pop3s.ssl.enable", "true");
|
|
} else {
|
|
props.put("mail.store.protocol", "pop3");
|
|
props.put("mail.pop3.host", mailServer);
|
|
props.put("mail.pop3.port", String.valueOf(mailPort));
|
|
}
|
|
}
|
|
|
|
Session session = Session.getInstance(props);
|
|
store = session.getStore();
|
|
store.connect(mailServer, mailPort, mailUsername, mailPassword);
|
|
|
|
folder = store.getFolder(mailFolder);
|
|
folder.open(Folder.READ_WRITE);
|
|
|
|
// Nachrichten abrufen
|
|
Message[] messages;
|
|
if (protocol.equals("IMAP")) {
|
|
// IMAP: Nur ungelesene
|
|
messages = folder.search(new FlagTerm(new Flags(Flags.Flag.SEEN), false));
|
|
} else {
|
|
// POP3: Alle (Tracking über processed-Liste)
|
|
messages = folder.getMessages();
|
|
}
|
|
|
|
log.info("Mail2Fax: " + messages.length + " Nachrichten gefunden");
|
|
|
|
for (Message message : messages) {
|
|
try {
|
|
processMessage(message, protocol.equals("POP3"), folder);
|
|
processedCount++;
|
|
} catch (Exception e) {
|
|
log.error("Mail2Fax: Fehler bei Nachricht: " + e.getMessage(), e);
|
|
errorCount++;
|
|
}
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
// Bei Verbindungsfehlern nur eine saubere Meldung ohne Stacktrace
|
|
String msg = e.getMessage();
|
|
if (e instanceof com.sun.mail.util.MailConnectException ||
|
|
e instanceof java.net.ConnectException ||
|
|
e instanceof java.net.UnknownHostException ||
|
|
e instanceof java.net.SocketTimeoutException ||
|
|
(msg != null && (msg.contains("Connection refused") ||
|
|
msg.contains("connect") ||
|
|
msg.contains("timeout") ||
|
|
msg.contains("Unknown host")))) {
|
|
log.error("Mail2Fax: Verbindung zu " + mailServer + ":" + mailPort + " fehlgeschlagen - " + msg);
|
|
} else {
|
|
log.error("Mail2Fax: E-Mail-Abruf fehlgeschlagen: " + msg, e);
|
|
}
|
|
errorCount++;
|
|
statusMessage = "Fehler: " + msg;
|
|
} finally {
|
|
try {
|
|
if (folder != null && folder.isOpen()) {
|
|
folder.close(true); // expunge deleted messages
|
|
}
|
|
if (store != null) {
|
|
store.close();
|
|
}
|
|
} catch (Exception e) {
|
|
log.warn("Mail2Fax: Fehler beim Schließen: " + e.getMessage());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verarbeitet eine einzelne E-Mail
|
|
*/
|
|
private void processMessage(Message message, boolean isPop3, Folder folder) throws Exception {
|
|
String messageId = getMessageId(message);
|
|
|
|
// Bei POP3: Prüfen ob bereits verarbeitet
|
|
if (isPop3 && isAlreadyProcessed(messageId)) {
|
|
log.debug("Mail2Fax: Nachricht bereits verarbeitet: " + messageId);
|
|
return;
|
|
}
|
|
|
|
String from = message.getFrom()[0].toString();
|
|
String subject = message.getSubject();
|
|
|
|
log.info("Mail2Fax: Verarbeite E-Mail von " + from + " - Betreff: " + subject);
|
|
|
|
// Absender prüfen
|
|
if (!isAuthorizedSender(from)) {
|
|
log.warn("Mail2Fax: Nicht autorisierter Absender: " + from);
|
|
if (!isPop3) {
|
|
message.setFlag(Flags.Flag.SEEN, true);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// PIN prüfen (wenn gesetzt)
|
|
if (pin != null && !pin.trim().isEmpty()) {
|
|
String emailBody = getEmailBodyText(message);
|
|
if (emailBody == null || !emailBody.contains(pin)) {
|
|
log.error("Mail2Fax: PIN in Emailtext nicht vorhanden oder falsch");
|
|
if (!isPop3) {
|
|
message.setFlag(Flags.Flag.SEEN, true);
|
|
}
|
|
return;
|
|
}
|
|
log.debug("Mail2Fax: PIN erfolgreich validiert");
|
|
}
|
|
|
|
// Ziel-Faxnummer aus Betreff extrahieren
|
|
String destination = extractFaxNumber(subject);
|
|
if (destination == null || destination.isEmpty()) {
|
|
// Spezifische Fehlermeldung je nach Grund
|
|
if (subjectPrefix != null && !subjectPrefix.trim().isEmpty() && !subject.startsWith(subjectPrefix.trim())) {
|
|
// Präfix stimmt nicht überein → Email NICHT als gelesen markieren
|
|
// So können andere Instanzen mit passendem Präfix die Email verarbeiten
|
|
log.debug("Mail2Fax: Betreff-Präfix stimmt nicht überein. Erwartet: '" + subjectPrefix.trim() + "', Betreff: " + subject + " - Email bleibt ungelesen für andere Instanzen");
|
|
return; // Ohne setFlag(SEEN) - andere Instanz könnte passen
|
|
} else {
|
|
// Keine gültige Faxnummer → als gelesen markieren
|
|
log.warn("Mail2Fax: Keine gültige Faxnummer im Betreff: " + subject);
|
|
if (!isPop3) {
|
|
message.setFlag(Flags.Flag.SEEN, true);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
// PDF-Anhänge suchen und verarbeiten
|
|
List<File> pdfFiles = extractPdfAttachments(message);
|
|
if (pdfFiles.isEmpty()) {
|
|
log.warn("Mail2Fax: Keine PDF-Anhänge gefunden");
|
|
if (!isPop3) {
|
|
message.setFlag(Flags.Flag.SEEN, true);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Jeden PDF-Anhang als Fax senden
|
|
boolean allSuccess = true;
|
|
for (File pdfFile : pdfFiles) {
|
|
int result = sendFax(destination, faxSenderNumber, pdfFile);
|
|
|
|
if (result == FAX_SUCCESS) {
|
|
sentFaxCount++;
|
|
pdfFile.delete();
|
|
} else if (result == FAX_RETRY) {
|
|
// In Retry-Queue aufnehmen
|
|
addToRetryQueue(destination, faxSenderNumber, pdfFile, messageId);
|
|
allSuccess = false;
|
|
} else {
|
|
errorCount++;
|
|
pdfFile.delete();
|
|
allSuccess = false;
|
|
}
|
|
}
|
|
|
|
// E-Mail als verarbeitet markieren
|
|
if (allSuccess) {
|
|
if (isPop3) {
|
|
// POP3: Als verarbeitet speichern und löschen
|
|
markAsProcessed(messageId);
|
|
message.setFlag(Flags.Flag.DELETED, true);
|
|
log.info("Mail2Fax: POP3-Nachricht zum Löschen markiert");
|
|
} else {
|
|
// IMAP: Als gelesen markieren, optional löschen
|
|
message.setFlag(Flags.Flag.SEEN, true);
|
|
if (deleteAfterProcess) {
|
|
message.setFlag(Flags.Flag.DELETED, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ermittelt die Message-ID einer E-Mail
|
|
*/
|
|
private String getMessageId(Message message) {
|
|
try {
|
|
String[] headers = message.getHeader("Message-ID");
|
|
if (headers != null && headers.length > 0) {
|
|
return headers[0];
|
|
}
|
|
// Fallback: Hash aus Datum und Betreff
|
|
return String.valueOf((message.getSentDate() + "|" + message.getSubject()).hashCode());
|
|
} catch (Exception e) {
|
|
return String.valueOf(System.currentTimeMillis());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prüft ob eine Nachricht bereits verarbeitet wurde (für POP3)
|
|
*/
|
|
private boolean isAlreadyProcessed(String messageId) {
|
|
try {
|
|
Path path = Paths.get(PROCESSED_FILE);
|
|
if (!Files.exists(path)) {
|
|
return false;
|
|
}
|
|
List<String> processed = Files.readAllLines(path);
|
|
return processed.contains(messageId);
|
|
} catch (Exception e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Markiert eine Nachricht als verarbeitet (für POP3)
|
|
*/
|
|
private void markAsProcessed(String messageId) {
|
|
try {
|
|
Path path = Paths.get(PROCESSED_FILE);
|
|
List<String> processed = Files.exists(path) ?
|
|
new ArrayList<>(Files.readAllLines(path)) : new ArrayList<>();
|
|
|
|
if (!processed.contains(messageId)) {
|
|
processed.add(messageId);
|
|
// Maximal 1000 Einträge behalten
|
|
while (processed.size() > 1000) {
|
|
processed.remove(0);
|
|
}
|
|
Files.write(path, processed);
|
|
}
|
|
} catch (Exception e) {
|
|
log.warn("Mail2Fax: Konnte Nachricht nicht als verarbeitet markieren: " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fügt ein fehlgeschlagenes Fax zur Retry-Queue hinzu
|
|
*/
|
|
private void addToRetryQueue(String destination, String senderNumber, File pdfFile, String messageId) {
|
|
try {
|
|
long nextRetry = System.currentTimeMillis() + (retryDelayMinutes * 60 * 1000L);
|
|
String entry = nextRetry + "|1|" + destination + "|" + senderNumber + "|" +
|
|
pdfFile.getAbsolutePath() + "|" + messageId;
|
|
|
|
Path path = Paths.get(RETRY_FILE);
|
|
List<String> entries = Files.exists(path) ?
|
|
new ArrayList<>(Files.readAllLines(path)) : new ArrayList<>();
|
|
entries.add(entry);
|
|
Files.write(path, entries);
|
|
|
|
pendingRetries++;
|
|
log.info("Mail2Fax: Fax zur Retry-Queue hinzugefügt: " + destination);
|
|
|
|
} catch (Exception e) {
|
|
log.error("Mail2Fax: Konnte nicht zur Retry-Queue hinzufügen: " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Prüft ob der Absender autorisiert ist
|
|
*/
|
|
private boolean isAuthorizedSender(String from) {
|
|
if (authorizedSenders == null || authorizedSenders.trim().isEmpty()) {
|
|
return true; // Keine Einschränkung
|
|
}
|
|
|
|
String fromLower = from.toLowerCase();
|
|
String[] authorized = authorizedSenders.split(",");
|
|
|
|
for (String auth : authorized) {
|
|
if (fromLower.contains(auth.trim().toLowerCase())) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Extrahiert die Faxnummer aus dem E-Mail-Betreff
|
|
*
|
|
* Wenn ein Betreff-Präfix konfiguriert ist, muss der Betreff damit beginnen.
|
|
* Der Präfix wird dann entfernt, bevor die Faxnummer extrahiert wird.
|
|
*
|
|
* Beispiel: subjectPrefix="FAXMaik:", subject="FAXMaik: +49721123456" → "+49721123456"
|
|
*/
|
|
private String extractFaxNumber(String subject) {
|
|
if (subject == null || subject.isEmpty()) {
|
|
return null;
|
|
}
|
|
|
|
// Wenn Präfix gesetzt ist, prüfen und entfernen
|
|
if (subjectPrefix != null && !subjectPrefix.trim().isEmpty()) {
|
|
String prefix = subjectPrefix.trim();
|
|
|
|
if (!subject.startsWith(prefix)) {
|
|
log.debug("Mail2Fax: Betreff beginnt nicht mit Präfix '" + prefix + "': " + subject);
|
|
return null;
|
|
}
|
|
|
|
// Präfix entfernen
|
|
subject = subject.substring(prefix.length()).trim();
|
|
log.debug("Mail2Fax: Präfix entfernt, verbleibender Betreff: " + subject);
|
|
}
|
|
|
|
// Entferne alle Zeichen außer Ziffern und +
|
|
String cleaned = subject.replaceAll("[^0-9+]", "");
|
|
|
|
// Prüfe auf gültiges Format
|
|
if (cleaned.matches("\\+?[0-9]{6,}")) {
|
|
return cleaned;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Extrahiert den Textinhalt einer E-Mail (für PIN-Prüfung)
|
|
*/
|
|
private String getEmailBodyText(Message message) {
|
|
try {
|
|
Object content = message.getContent();
|
|
|
|
if (content instanceof String) {
|
|
return (String) content;
|
|
} else if (content instanceof Multipart) {
|
|
Multipart multipart = (Multipart) content;
|
|
StringBuilder bodyText = new StringBuilder();
|
|
|
|
for (int i = 0; i < multipart.getCount(); i++) {
|
|
BodyPart bodyPart = multipart.getBodyPart(i);
|
|
String contentType = bodyPart.getContentType().toLowerCase();
|
|
|
|
// Nur Text-Parts auslesen, keine Anhänge
|
|
if (contentType.startsWith("text/plain") || contentType.startsWith("text/html")) {
|
|
Object partContent = bodyPart.getContent();
|
|
if (partContent instanceof String) {
|
|
bodyText.append((String) partContent);
|
|
}
|
|
}
|
|
}
|
|
return bodyText.toString();
|
|
}
|
|
} catch (Exception e) {
|
|
log.warn("Mail2Fax: Fehler beim Lesen des E-Mail-Textes: " + e.getMessage());
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Extrahiert PDF-Anhänge aus der E-Mail
|
|
*/
|
|
private List<File> extractPdfAttachments(Message message) throws Exception {
|
|
List<File> pdfFiles = new ArrayList<>();
|
|
|
|
Object content = message.getContent();
|
|
if (content instanceof Multipart) {
|
|
Multipart multipart = (Multipart) content;
|
|
|
|
for (int i = 0; i < multipart.getCount(); i++) {
|
|
BodyPart bodyPart = multipart.getBodyPart(i);
|
|
|
|
if (Part.ATTACHMENT.equalsIgnoreCase(bodyPart.getDisposition()) ||
|
|
(bodyPart.getFileName() != null && bodyPart.getFileName().toLowerCase().endsWith(".pdf"))) {
|
|
|
|
String fileName = bodyPart.getFileName();
|
|
if (fileName != null && fileName.toLowerCase().endsWith(".pdf")) {
|
|
// Temp-Datei erstellen
|
|
File tempFile = File.createTempFile("mail2fax_", ".pdf");
|
|
|
|
try (InputStream is = bodyPart.getInputStream();
|
|
FileOutputStream fos = new FileOutputStream(tempFile)) {
|
|
byte[] buffer = new byte[4096];
|
|
int bytesRead;
|
|
while ((bytesRead = is.read(buffer)) != -1) {
|
|
fos.write(buffer, 0, bytesRead);
|
|
}
|
|
}
|
|
|
|
log.info("Mail2Fax: PDF extrahiert: " + fileName);
|
|
pdfFiles.add(tempFile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return pdfFiles;
|
|
}
|
|
|
|
/**
|
|
* Sendet ein PDF als Fax über die STARFACE API
|
|
*
|
|
* Verwendet den internen FaxHandler über den StarfaceComponentProvider.
|
|
*
|
|
* @return FAX_SUCCESS, FAX_RETRY oder FAX_FAIL
|
|
*/
|
|
private int sendFax(String destination, String callingNumber, File pdfFile) {
|
|
try {
|
|
log.info("Mail2Fax: Sende Fax an " + destination + " von " + callingNumber);
|
|
|
|
// Den eingebauten SendFax-Block direkt instanziieren und aufrufen
|
|
Class<?> sendFaxClass = Class.forName(
|
|
"de.vertico.starface.module.core.runtime.functions.callHandling.call.SendFax"
|
|
);
|
|
|
|
Object sendFaxBlock = sendFaxClass.getDeclaredConstructor().newInstance();
|
|
|
|
// Input-Variablen setzen via Reflection
|
|
// accountId (Integer) - Benutzer-ID für Fax-Versand
|
|
setFieldValue(sendFaxClass, sendFaxBlock, "accountId", faxAccountId);
|
|
|
|
// extention (String) - Ziel-Faxnummer (Tippfehler im Original!)
|
|
setFieldValue(sendFaxClass, sendFaxBlock, "extention", destination);
|
|
|
|
// signalNumber (String) - Absender-Nummer
|
|
setFieldValue(sendFaxClass, sendFaxBlock, "signalNumber", callingNumber);
|
|
|
|
// signalName (String) - Absender-Name (optional, gleich wie Nummer)
|
|
setFieldValue(sendFaxClass, sendFaxBlock, "signalName", callingNumber);
|
|
|
|
// resource (String) - Pfad zur PDF-Datei
|
|
setFieldValue(sendFaxClass, sendFaxBlock, "resource", pdfFile.getAbsolutePath());
|
|
|
|
// execute() aufrufen mit unserem Runtime
|
|
java.lang.reflect.Method executeMethod = sendFaxClass.getMethod("execute",
|
|
Class.forName("de.vertico.starface.module.core.runtime.IRuntimeEnvironment"));
|
|
executeMethod.invoke(sendFaxBlock, runtime);
|
|
|
|
// Ergebnis prüfen (exitStatus Feld)
|
|
try {
|
|
java.lang.reflect.Field exitStatusField = sendFaxClass.getDeclaredField("exitStatus");
|
|
exitStatusField.setAccessible(true);
|
|
Object exitStatus = exitStatusField.get(sendFaxBlock);
|
|
log.info("Mail2Fax: SendFax exitStatus: " + exitStatus);
|
|
|
|
if (exitStatus != null) {
|
|
String status = exitStatus.toString();
|
|
|
|
// BUSY, FAILED oder andere temporäre Fehler → Retry
|
|
if (status.contains("BUSY") || status.contains("FAILED") ||
|
|
status.contains("NO_ANSWER") || status.contains("TIMEOUT")) {
|
|
log.info("Mail2Fax: Temporärer Fehler (" + status + "), wird zur Retry-Queue hinzugefügt");
|
|
return FAX_RETRY;
|
|
}
|
|
|
|
// SENT → Erfolg
|
|
if (status.contains("SENT")) {
|
|
log.info("Mail2Fax: Fax erfolgreich gesendet an " + destination);
|
|
return FAX_SUCCESS;
|
|
}
|
|
|
|
// Unbekannter Status → als Fehler behandeln
|
|
log.warn("Mail2Fax: Unbekannter exitStatus: " + status);
|
|
return FAX_FAIL;
|
|
}
|
|
} catch (NoSuchFieldException e) {
|
|
log.debug("Mail2Fax: Kein exitStatus Feld");
|
|
}
|
|
|
|
// Kein exitStatus gefunden → als Erfolg annehmen (Fallback)
|
|
log.info("Mail2Fax: Fax gesendet an " + destination + " (kein exitStatus verfügbar)");
|
|
return FAX_SUCCESS;
|
|
|
|
} catch (Exception e) {
|
|
String error = e.getMessage() != null ? e.getMessage().toLowerCase() : "";
|
|
log.error("Mail2Fax: Fax-Fehler: " + e.getMessage(), e);
|
|
|
|
// Prüfe ob Retry sinnvoll ist
|
|
if (error.contains("busy") || error.contains("besetzt") ||
|
|
error.contains("no answer") || error.contains("keine antwort") ||
|
|
error.contains("temporarily") || error.contains("timeout")) {
|
|
log.info("Mail2Fax: Temporärer Fehler, wird erneut versucht");
|
|
return FAX_RETRY;
|
|
}
|
|
|
|
return FAX_FAIL;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Versucht ein Feld zu setzen, gibt true zurück wenn erfolgreich
|
|
*/
|
|
private boolean trySetField(Class<?> clazz, Object obj, String fieldName, Object value) {
|
|
try {
|
|
java.lang.reflect.Field field = clazz.getDeclaredField(fieldName);
|
|
field.setAccessible(true);
|
|
field.set(obj, value);
|
|
log.debug("Mail2Fax: " + fieldName + " gesetzt: " + value);
|
|
return true;
|
|
} catch (NoSuchFieldException e) {
|
|
return false;
|
|
} catch (Exception e) {
|
|
log.warn("Mail2Fax: Fehler beim Setzen von " + fieldName + ": " + e.getMessage());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Setzt ein Feld oder wirft Exception
|
|
*/
|
|
private void setFieldValue(Class<?> clazz, Object obj, String fieldName, Object value) throws Exception {
|
|
java.lang.reflect.Field field = clazz.getDeclaredField(fieldName);
|
|
field.setAccessible(true);
|
|
field.set(obj, value);
|
|
log.debug("Mail2Fax: " + fieldName + " gesetzt: " + value);
|
|
}
|
|
}
|