collection = ctx.getLoggers();
+ return collection;
+ }
+
+ public boolean getDebug() { return isDebug; }
+
+ /**
+ * Get's name of Logger (Class)
+ *
+ * @return loggername
+ *
+ */
+ public String getLoggerName() { return LOGGER.getName(); }
+
+ /**
+ *
+ * @return
+ * Current loggedin User
+ */
+ public String getUser() { return user; }
+
+ /**
+ * Logs entry to a method. Used when the method in question has no parameters or when the parameters should not belogged.
+ *
+ * SOURCE: SYSTEM
+ */
+ public void logEntry() {
+ setMethod();
+ setParam("SOURCE", Log4j2Source.SYSTEM.name());
+ LOGGER.traceEntry();
+ }
+
+ /**
+ * Logs exit from a method. Used for methods that do not return anything.
+ *
+ * SOURCE: SYSTEM
+ */
+ public void logExit() {
+ setMethod();
+ setParam("SOURCE", Log4j2Source.SYSTEM.name());
+ LOGGER.traceExit();
+ }
+
+ /**
+ * Logs a message object with the given level.
+ *
+ * @param logLevel
+ * TRACE / DEBUG / INFO / WARN / ERROR / FATAL
+ * @param log4j2Source
+ * DATABASE / SYSTEM / PROGRAM / TOOLS
+ * @param msg
+ * Optional Message
+ */
+ public void log(Level logLevel, Log4j2Source log4j2Source, String msg) {
+ setMethod();
+ setUsername(getUser());
+ setParam("SOURCE", log4j2Source.name());
+ LOGGER.log(logLevel, msg);
+ }
+
+ /**
+ * Logs a message object with the given level.
+ *
+ * @param logLevel
+ * TRACE / DEBUG / INFO / WARN / ERROR / FATAL
+ * @param log4j2Source
+ * DATABASE / SYSTEM / PROGRAM / TOOLS
+ * @param exception
+ * Thrown Exeption
+ */
+ public void log(Level logLevel, Log4j2Source log4j2Source, Exception exception) {
+ setMethod(exception);
+ setUsername(getUser());
+ setParam("SOURCE", log4j2Source.name());
+ LOGGER.log(logLevel, subExceptionMsg(ExceptionWriter(exception)));
+ }
+
+ /**
+ * Logs a message object with the given level.
+ *
+ * @param logLevel
+ * TRACE / DEBUG / INFO / WARN / ERROR / FATAL
+ * @param log4j2Source
+ * DATABASE / SYSTEM / PROGRAM / TOOLS
+ * @param exception
+ * Thrown Exeption
+ * @param msg
+ * Optional Message
+ *
+ */
+ public void log(Level logLevel, Log4j2Source log4j2Source, Exception exception, String msg) {
+ setMethod(exception);
+ setUsername(getUser());
+ setParam("SOURCE", log4j2Source.name());
+ LOGGER.log(logLevel, msg, subExceptionMsg(ExceptionWriter(exception)));
+ }
+
+ /**
+ * Logs a message object with the given level.
+ *
+ * @param logLevel
+ * TRACE / DEBUG / INFO / WARN / ERROR / FATAL
+ * @param log4j2Source
+ * DATABASE / SYSTEM / PROGRAM / TOOLS
+ * @param obj
+ * Does object.toString()
+ *
+ */
+ public void log(Level logLevel, Log4j2Source log4j2Source, Object obj) {
+ setMethod();
+ setUsername(getUser());
+ setParam("SOURCE", log4j2Source.name());
+ LOGGER.log(logLevel, obj);
+ }
+
+ /**
+ *
+ * Logs a message object with the given level.
+ * Send Mail even if email = null, else only to the Mail who specified
+ *
+ * @param logLevel
+ * TRACE / DEBUG / INFO / WARN / ERROR / FATAL
+ * @param log4j2Source
+ * DATABASE / SYSTEM / PROGRAM / TOOLS
+ * @param msg
+ * Optional Message
+ * @param exception
+ * Thrown Exeption
+ * @param emails
+ */
+ public void log(Level logLevel, Log4j2Source log4j2Source, String msg, Exception exception, String[] emails) {
+// setMethod(exception);
+// setUsername(getUser());
+// setParam("SOURCE", log4j2Source.name());
+// if (msg == null) {
+// LOGGER.log(logLevel, ExceptionWriter(exception));
+// if (emails != null) {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(subExceptionMsg(ExceptionWriter(exception))), emails, null);
+// }
+// else {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(subExceptionMsg(ExceptionWriter(exception))), new String[0], null);
+// }
+// }
+// else if (msg.equals("") || msg.equals(exception.getMessage())) {
+// LOGGER.log(logLevel, ExceptionWriter(exception));
+// if (emails != null) {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(subExceptionMsg(ExceptionWriter(exception))), emails, null);
+// }
+// else {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(subExceptionMsg(ExceptionWriter(exception))), new String[0], null);
+// }
+// }
+// else {
+// LOGGER.log(logLevel, msg, exception);
+// if (emails != null) {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(subExceptionMsg(ExceptionWriter(exception))), subExceptionMsg(msg), emails, null);
+// }
+// else {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(subExceptionMsg(ExceptionWriter(exception))), subExceptionMsg(msg), new String[0], null);
+// }
+// }
+ }
+
+ /**
+ * Logs a message object with the given level.
+ *
+ * @param logLevel
+ * TRACE / DEBUG / INFO / WARN / ERROR / FATAL
+ * @param log4j2Source
+ * DATABASE / SYSTEM / PROGRAM / TOOLS
+ * @param exception
+ * Thrown Exeption
+ *
+ */
+ public void log(Level logLevel, Log4j2Source log4j2Source, Throwable throwable) {
+ setMethod(throwable);
+ setUsername(getUser());
+ setParam("SOURCE", log4j2Source.name());
+ LOGGER.log(logLevel, subExceptionMsg(ExceptionWriter(throwable)));
+ }
+
+ /**
+ * Logs a message object with the given level.
+ * Ignores msg if null
+ *
+ * @param logLevel
+ * TRACE / DEBUG / INFO / WARN / ERROR / FATAL
+ * @param log4j2Source
+ * DATABASE / SYSTEM / PROGRAM / TOOLS
+ * @param msg
+ * Optional Message
+ * @param throwable
+ * Throwable
+ */
+ public void log(Level logLevel, Log4j2Source log4j2Source, String msg, Throwable throwable) {
+ setMethod(throwable);
+ setUsername(getUser());
+ setParam("SOURCE", log4j2Source.name());
+ if (msg == null) {
+ LOGGER.log(logLevel, subExceptionMsg(ExceptionWriter(throwable)));
+ }
+ LOGGER.log(logLevel, msg, throwable);
+ }
+
+ /**
+ *
+ * Logs a message object with the given level.
+ * Send Mail even if email = null, else only to the Mail who specified
+ *
+ * @param logLevel
+ * TRACE / DEBUG / INFO / WARN / ERROR / FATAL
+ * @param log4j2Source
+ * DATABASE / SYSTEM / PROGRAM / TOOLS
+ * @param msg
+ * Optional Message
+ * @param throwable
+ * Throwable
+ * @param emails
+ */
+ public void log(Level logLevel, Log4j2Source log4j2Source, String msg, Throwable throwable, String[] emails) {
+// setMethod(throwable);
+// setUsername(getUser());
+// setParam("SOURCE", log4j2Source.name());
+// if (msg == null) {
+// LOGGER.log(logLevel, ExceptionWriter(throwable));
+// if (emails != null) {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(ExceptionWriter(throwable)), emails, null);
+// }
+// else {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(ExceptionWriter(throwable)), new String[0], null);
+// }
+// }
+// else if (msg.equals("") || msg.equals(throwable.getMessage())) {
+// LOGGER.log(logLevel, ExceptionWriter(throwable));
+// if (emails != null) {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(ExceptionWriter(throwable)), emails, null);
+// }
+// else {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(ExceptionWriter(throwable)), new String[0], null);
+// }
+// }
+// else {
+// LOGGER.log(logLevel, msg, throwable);
+// if (emails != null) {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(ExceptionWriter(throwable)), msg, emails, null);
+// }
+// else {
+// sendMail(logLevel, log4j2Source, prettyExceptionEmail(ExceptionWriter(throwable)), msg, new String[0], null);
+// }
+// }
+ }
+
+ /**
+ * Only Used for Dispatcher Error
+ * Logs a message object with the FATAL level.
+ *
+ * @param msg
+ * Optional Message
+ * @param exception
+ * Thrown Exception
+ */
+ public void logFatalDispatcher(String msg, Exception exception) {
+ setMethod(exception);
+ setUsername(getUser());
+ Log4j2Source source = Log4j2Source.SYSTEM;
+ setParam("SOURCE", source.name());
+ LOGGER.fatal(ExceptionWriter(exception));
+// sendMail(Level.FATAL, source, prettyExceptionEmail(ExceptionWriter(exception)), new String[0], null);
+ }
+
+ /**
+ * Only Used for Dispatcher Error
+ * Logs a message object with the FATAL level.
+ *
+ * @param msg
+ * Optional Message
+ * @param throwable
+ * Throwable
+ */
+ public void logFatalDispatcher(String msg, Throwable throwable) {
+ setMethod(throwable);
+ setUsername(getUser());
+ Log4j2Source source = Log4j2Source.SYSTEM;
+ setParam("SOURCE", source.name());
+ LOGGER.fatal(ExceptionWriter(throwable));
+// sendMail(Level.FATAL, source, prettyExceptionEmail(ExceptionWriter(throwable)), new String[0], null);
+ }
+
+ /**
+ * Replaces \t with tabs who is understanding from Email-Client
+ *
+ * @param s
+ * Exeption as String
+ * @return
+ * String
+ */
+ private String prettyExceptionEmail(String s) {
+ return s.replace("\t", " ");
+ }
+
+ /**
+ * Wird nur in der PIC_Log4j2Bean benötigt. Reloads die Config von xml
+ */
+ public void reconfigureLogger() {
+ ctx.reconfigure();
+ }
+
+ /**
+ * Private method to send Mail if needed
+ *
+ * @param level
+ * @param source
+ * @param freitext
+ * @param email
+ * @param emailanhang
+ */
+// private void sendMail(Level level, Log4j2Source source, String freitext, String msg, String[] email, MailAttachment[] emailanhang) {
+// try {
+// StringBuilder mb = new StringBuilder();
+// String subject = "";
+//
+// SimpleDateFormat df = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
+//
+// mb.append(df.format(new Date()));
+// mb.append(" - ");
+// mb.append(source.name());
+// mb.append(" - ");
+// if (WorkplaceConfig.getWorkplaceEnvironment())
+// mb.append("Test");
+// else
+// mb.append("Echt");
+// mb.append(" - ");
+// mb.append(level.name());
+// mb.append(" - ");
+// mb.append(clazz.getCanonicalName());
+// user = (!getUser().isEmpty() ? user : ("UNKNOWN"));
+// if (user != null) {
+// mb.append(" - " + user);
+// }
+//
+// mb.append(" -- " + SessionUtil.getServerHostname());
+// mb.append(" -- " + SessionUtil.getSessionName());
+//
+// subject = mb.toString();
+// mb = new StringBuilder();
+// mb.append(msg);
+// mb.append("\r\n");
+// mb.append(System.getProperty("line.separator"));
+// mb.append(freitext);
+// mb.append(System.getProperty("line.separator"));
+//
+// String body = mb.toString();
+//
+// if (email != null) {
+// if (isDebug) {
+// System.out.println("Subject: " + subject + "\nMesage: " + body);
+// }
+// if (email.length <= 0) {
+// EmailHandler.sentLog4jMail(subject, body, null, emailanhang);
+//// logInfo("Sent Email", Log4j2Source.PROGRAM);
+// }
+// else {
+// EmailHandler.sentLog4jMail(subject, body, email, emailanhang);
+//// logInfo("Sent Email", Log4j2Source.PROGRAM);
+// }
+// }
+// }
+// catch (Exception e) {
+// setMethod();
+// LOGGER.fatal(e);
+// }
+// }
+
+ /**
+ * Private method to send Mail if needed
+ *
+ * @param level
+ * @param source
+ * @param freitext
+ * @param email
+ * @param emailanhang
+ */
+ private void sendMail(Level level, Log4j2Source source, String freitext, String[] email, MailAttachment[] emailanhang) {
+ try {
+ StringBuilder mb = new StringBuilder();
+ String subject = "";
+
+ SimpleDateFormat df = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
+
+ mb.append(df.format(new Date()));
+ mb.append(" - ");
+ mb.append(source.name());
+ mb.append(" - ");
+ if (WorkplaceConfig.getWorkplaceEnvironment())
+ mb.append("Test");
+ else
+ mb.append("Echt");
+ mb.append(" - ");
+ mb.append(level.name());
+ mb.append(" - ");
+ mb.append(clazz.getCanonicalName());
+ user = (!getUser().isEmpty() ? user : ("UNKNOWN"));
+ if (user != null) {
+ mb.append(" - " + user);
+ }
+
+ mb.append(" -- " + SessionUtil.getServerHostname());
+ mb.append(" -- " + SessionUtil.getSessionName());
+
+ subject = mb.toString();
+
+ mb.append(System.getProperty("line.separator"));
+ mb.append(freitext);
+ mb.append(System.getProperty("line.separator"));
+
+ if (email != null) {
+ if (isDebug) {
+ System.out.println("Subject: " + subject + "\nMesage: " + freitext);
+ }
+ if (email.length <= 0) {
+// EmailHandler.sentLog4jMail(subject, freitext, null, emailanhang);
+// logInfo("Sent Email", Log4j2Source.PROGRAM);
+ }
+ else {
+// EmailHandler.sentLog4jMail(subject, freitext, email, emailanhang);
+// logInfo("Sent Email", Log4j2Source.PROGRAM);
+ }
+ }
+ }
+ catch (Exception e) {
+ setMethod();
+ LOGGER.fatal(e);
+ }
+ }
+
+ /**
+ *
+ * Method to create own Errormails
+ *
+ * @param level
+ * TRACE / DEBUG / INFO / WARN / ERROR / FATAL
+ * @param source
+ * DATABASE / SYSTEM / PROGRAM / TOOLS
+ * @param text
+ * Optional Message
+ * @param emails
+ * @param errorUser
+ * User who is Displayed in Mail
+ * @param emailArrachment
+ * @param logClass
+ * Which class called this Method
+ */
+ public void sendMail(Level level, Log4j2Source source, String text, String[] email, String errorUser, MailAttachment[] emailArrachment, Object logClass) {
+ try {
+ StringBuilder mb = new StringBuilder();
+ String subject = "";
+ String message = "";
+
+ SimpleDateFormat df = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss");
+
+ if (level == null) {
+ level = LOGGER.getLevel();
+ }
+
+ mb.append(df.format(new Date()));
+ mb.append(" - ");
+ mb.append(source.name());
+ mb.append(" - ");
+ if (WorkplaceConfig.getWorkplaceEnvironment())
+ mb.append("Test");
+ else
+ mb.append("Echt");
+ mb.append(" - ");
+ mb.append(level.name());
+ mb.append(" - ");
+ mb.append(logClass.getClass().getCanonicalName());
+ user = (!getUser().isEmpty() ? user : ("UNKNOWN"));
+ if (user != null) {
+ mb.append(" - " + user);
+ }
+
+ mb.append(" -- " + SessionUtil.getServerHostname());
+ mb.append(" -- " + SessionUtil.getSessionName());
+
+ subject = mb.toString();
+
+ mb.append(System.getProperty("line.separator"));
+ mb.append(text);
+ mb.append(System.getProperty("line.separator"));
+
+ message = text;
+
+ setMethod();
+ if (errorUser == null) {
+ setUser(getUser());
+ } else {
+ setUsername(errorUser);
+ }
+
+ setParam("SOURCE", source.name());
+ LOGGER.log(level, text);
+
+ if (isDebug) {
+ System.out.println("Subject: " + subject + "\nMesage: " + text);
+ }
+ if (email == null || email.length <= 0) {
+// EmailHandler.sentLog4jMail(subject, message, null, emailArrachment);
+// logInfo("Sent Email", Log4j2Source.PROGRAM);
+ }
+ else {
+// EmailHandler.sentLog4jMail(subject, message, email, emailArrachment);
+// logInfo("Sent Email", Log4j2Source.PROGRAM);
+ }
+ }
+ catch (Exception e) {
+ setMethod();
+ LOGGER.fatal(e);
+ }
+ }
+
+ /**
+ * Aktuell nur für Email-Debugging
+ * Sendet EMail und gibt in Console aus
+ *
+ * @param isDebug
+ */
+ public void setDebug(boolean isDebug) { this.isDebug = isDebug; }
+
+ /**
+ * Sets Class, Methodname, linenumber for Log
+ */
+ private void setMethod() {
+ StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+ String methodName = "";
+ int lineNumber = 0;
+ String fileName = "";
+ for (StackTraceElement stackTraceElement : stackTraceElements) {
+ methodName = stackTraceElement.getMethodName();
+ lineNumber = stackTraceElement.getLineNumber();
+ fileName = stackTraceElement.getFileName();
+
+ if (stackTraceElement.getClassName().startsWith("de.geis") && !methodName.equals("setMethod") && !methodName.equals("log") && !methodName.equals("subExceptionMsg")) {
+ break;
+ }
+ }
+ methodName = methodName.replace("<", "");
+ methodName = methodName.replace(">", "");
+
+ if (fileName != null) {
+ fileName = fileName.replace(".java", "");
+ }
+ ThreadContext.put("METHOD".toUpperCase(), methodName);
+ ThreadContext.put("LINE", lineNumber + "");
+ ThreadContext.put("FILE", fileName);
+ }
+
+ private void setMethod(Object exceptionOrThrowable) {
+ if (exceptionOrThrowable instanceof Exception) {
+ Exception exception = (Exception) exceptionOrThrowable;
+ StackTraceElement[] stackTraceElements = exception.getStackTrace();
+ for (StackTraceElement stackTraceElement : stackTraceElements) {
+ if (stackTraceElement.getClassName().startsWith("de.geis") && !stackTraceElement.getMethodName().equals("setMethod") && !stackTraceElement.getMethodName().equals("log") && !stackTraceElement.getMethodName().equals("subExceptionMsg")) {
+ setMethod(stackTraceElement.getMethodName(), stackTraceElement.getFileName(), stackTraceElement.getLineNumber(), exception.getClass().getSimpleName());
+ break;
+ }
+ }
+ }
+ else if (exceptionOrThrowable instanceof Throwable) {
+ Throwable throwable = (Throwable) exceptionOrThrowable;
+ StackTraceElement[] stackTraceElements = throwable.getStackTrace();
+ for (StackTraceElement stackTraceElement : stackTraceElements) {
+ if (stackTraceElement.getClassName().startsWith("de.geis") && !stackTraceElement.getMethodName().equals("setMethod") && !stackTraceElement.getMethodName().equals("log") && !stackTraceElement.getMethodName().equals("subExceptionMsg")) {
+ setMethod(stackTraceElement.getMethodName(), stackTraceElement.getFileName(), stackTraceElement.getLineNumber(), throwable.getClass().getSimpleName());
+ break;
+ }
+ }
+ }
+ }
+
+ /**
+ * Only use if setMethod() does not work
+ *
+ * @param method
+ * @param file
+ * @param line
+ * @param exception
+ */
+ private void setMethod(String method, String file, Integer line, String exception) {
+ method = method.replace("<", "");
+ method = method.replace(">", "");
+
+ file = file.replace(".java", "");
+ ThreadContext.put("METHOD".toUpperCase(), method);
+ ThreadContext.put("LINE", line + "");
+ ThreadContext.put("FILE", file);
+ ThreadContext.put("EXCEPTION", exception);
+ }
+
+ /**
+ * Setzt weitere parameter
+ *
+ *
+ * Aktuell nicht benötigt bzw. sinnvoll
+ *
+ *
+ * @param Param
+ * @param value
+ */
+ private void setParam(String Param, String value) {
+ ThreadContext.put(Param.toUpperCase(), value);
+ }
+
+ public void setUser(String username) { user = username; }
+
+ /**
+ * Sets Username for Log
+ *
+ * @param username
+ */
+ public void setUsername(String username) {
+ ThreadContext.put("USERNAME", username);
+ user = username;
+ }
+
+ /**
+ * Removes the "java.lang.Error:" in front of Exception
+ *
+ * @param msg
+ * @return
+ */
+ private String subExceptionMsg(String msg) {
+ try {
+ if (msg.trim().startsWith("java.lang.Error: ")) {
+ while (msg.trim().startsWith("java.lang.Error: ")) {
+ int index = msg.trim().indexOf("java.lang.Error: ") + 17;
+ msg = msg.trim().substring(index, msg.trim().length());
+ }
+
+ return msg;
+ }
+ else {
+ return msg;
+ }
+ }
+ catch (Exception e) {
+ e.printStackTrace();
+ return msg;
+ }
+ }
+}
diff --git a/src/main/java/de/tvo/mailer/MailAttachment.java b/src/main/java/de/tvo/mailer/MailAttachment.java
new file mode 100644
index 0000000..408c9ac
--- /dev/null
+++ b/src/main/java/de/tvo/mailer/MailAttachment.java
@@ -0,0 +1,65 @@
+package de.tvo.mailer;
+
+import java.io.File;
+import java.io.Serializable;
+
+import org.apache.commons.codec.binary.Base64;
+
+
+public class MailAttachment implements Serializable {
+
+ private static final long serialVersionUID = 1L;
+
+ private String fileName = "emptyfile.dat";
+ private byte[] fileContent = null;
+ private File file = null;
+ private boolean deleteFile = false;
+
+ public MailAttachment(String fileName, byte[] fileContent) {
+ this.fileName = fileName;
+ this.fileContent = fileContent;
+ }
+
+ public MailAttachment(String fileName, File file, boolean deleteFile) {
+ this.fileName = fileName;
+ this.file = file;
+ this.deleteFile = deleteFile;
+ }
+
+ public MailAttachment(String fileName, File file) {
+ this(fileName, file, false);
+ }
+
+ public byte[] getFileContent() {
+ return fileContent;
+ }
+
+ public void setFileContent(byte[] fileContent) {
+ this.fileContent = fileContent;
+ }
+
+ public String getFileName() {
+ return fileName;
+ }
+
+ public void setFileName(String fileName) {
+ this.fileName = fileName;
+ }
+
+ public File getFile() {
+ return file;
+ }
+
+ public void setFile(File file) {
+ this.file = file;
+ }
+
+ public boolean getDeleteFile() {
+ return deleteFile;
+ }
+
+ public String getBase64EncodedString() {
+ return Base64.encodeBase64String(getFileContent());
+ }
+
+}
diff --git a/src/main/java/de/tvo/nanoleaf/enums/NanoTypeEnum.java b/src/main/java/de/tvo/nanoleaf/enums/NanoTypeEnum.java
new file mode 100644
index 0000000..caed469
--- /dev/null
+++ b/src/main/java/de/tvo/nanoleaf/enums/NanoTypeEnum.java
@@ -0,0 +1,14 @@
+package de.tvo.nanoleaf.enums;
+
+public enum NanoTypeEnum {
+
+ CANVAS,
+
+ SHAPES,
+
+
+
+ ;
+
+
+}
diff --git a/src/main/java/de/tvo/nanoleaf/oclasses/MatrixInfo.java b/src/main/java/de/tvo/nanoleaf/oclasses/MatrixInfo.java
new file mode 100644
index 0000000..092b855
--- /dev/null
+++ b/src/main/java/de/tvo/nanoleaf/oclasses/MatrixInfo.java
@@ -0,0 +1,33 @@
+package de.tvo.nanoleaf.oclasses;
+
+public class MatrixInfo {
+
+ int m_matrixX = 0;
+ int m_matrixY = 0;
+ //int m_Panels = 1;
+
+ public MatrixInfo(int matrixX, int matrixY) {
+ //this.m_Panels = Panels;
+ this.m_matrixX = matrixX;
+ this.m_matrixY = matrixY;
+ }
+
+ public int getMatrixX() {
+ return m_matrixX;
+ }
+
+ public void setMatrixX(int matrixX) {
+ m_matrixX = matrixX;
+ }
+
+ public int getMatrixY() {
+ return m_matrixY;
+ }
+
+ public void setMatrixY(int matrixY) {
+ m_matrixY = matrixY;
+ }
+
+
+
+}
diff --git a/src/main/java/de/tvo/session/SessionTyp.java b/src/main/java/de/tvo/session/SessionTyp.java
new file mode 100644
index 0000000..025a648
--- /dev/null
+++ b/src/main/java/de/tvo/session/SessionTyp.java
@@ -0,0 +1,12 @@
+package de.tvo.session;
+
+public enum SessionTyp {
+
+ PORTAL_SESSION, // Reguläre User Session
+ PORTAL_TOKEN_SESSION, // Sitzung die sich automatisch anmeldet über ein valides Token (gatway.risc?token=abc)
+ MDE_SESSION, // der MDE Server mit anderen Menüs speziell für die MDEs
+ CLIENT_SESSION, // Wenn Server und Client die selbe IP hat, quasi Embedded
+
+
+ ;
+}
diff --git a/src/main/java/de/tvo/session/SessionUtil.java b/src/main/java/de/tvo/session/SessionUtil.java
new file mode 100644
index 0000000..a9e58b9
--- /dev/null
+++ b/src/main/java/de/tvo/session/SessionUtil.java
@@ -0,0 +1,416 @@
+package de.tvo.session;
+
+import java.net.InetAddress;
+import java.net.UnknownHostException;
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import org.eclnt.jsfserver.util.HttpSessionAccess;
+import org.xbill.DNS.Lookup;
+import org.xbill.DNS.PTRRecord;
+import org.xbill.DNS.Record;
+import org.xbill.DNS.SimpleResolver;
+import org.xbill.DNS.Type;
+
+import de.tvo.tools.StringUtil;
+import jakarta.servlet.http.HttpSession;
+
+public class SessionUtil {
+
+ private SessionUtil() {
+
+ }
+
+ /**
+ * Function to return Client IP
+ * @return Client IP
+ */
+ public static String getClientIP(){
+ return HttpSessionAccess.getCurrentRequest().getRemoteAddr();
+ }
+
+ /**
+ * Function to return Client Hostname for Portal Server
+ * @return Client Hostname
+ */
+ public static String getClientHostname() {
+ return getClientHostname(SessionTyp.PORTAL_SESSION);
+ }
+
+ /**
+ * Function to return Client Hostname
+ * @return Client Hostname
+ */
+ public static String getClientHostname(SessionTyp sessionTyp) {
+ System.out.println("getClientHostname: " + sessionTyp);
+
+ String clientIP = getClientIP();
+ System.out.println("clientIP " + clientIP);
+
+ if (StringUtil.safeTrim(clientIP).equals("0:0:0:0:0:0:0:1") || StringUtil.safeTrim(clientIP).equals("127.0.0.1")) {
+ sessionTyp = SessionTyp.PORTAL_SESSION;
+ }
+
+ try {
+ switch (sessionTyp) {
+ case CLIENT_SESSION:
+ case PORTAL_SESSION: {
+
+
+ String ipAddress = InetAddress.getByName(HttpSessionAccess.getCurrentRequest().getRemoteAddr()).getHostName();
+ if (ipAddress != null) {
+ if (ipAddress.indexOf(".") != -1) {
+ return ipAddress.substring(0, ipAddress.indexOf(".")).toUpperCase();
+ } else {
+ return ipAddress.toUpperCase();
+ }
+ }
+
+ break;
+ }
+
+// case MDE_SESSION: {
+// String clientName = null;
+// System.out.println("clientIP " + clientIP);
+//
+// if (StringUtil.safeTrim(clientIP).equals("0:0:0:0:0:0:0:1")) {
+// clientIP = getServerIP();
+// }
+//
+//
+//
+// if (StringUtil.getCountLetter(clientIP, '.') == 3) {
+// DBHandler dbHandler = new DBHandler(WorkplaceConfig.getWorkplaceEnvironment() ? SchemataENUM.GEISV8T : SchemataENUM.GEISV8E);
+// StringBuilder sqlBuilder = new StringBuilder();
+// sqlBuilder.append("select pakey2 ");
+// sqlBuilder.append("from Gxpadat ");
+// sqlBuilder.append("where pakonz='EDV' and pafirm='MDE' ");
+// sqlBuilder.append("and pawert='MDEHOSTNAMEN' and pakey1='" + clientIP + "' ");
+//
+//
+// List clientList = dbHandler.jdbcSelect(sqlBuilder.toString());
+// System.out.println("clientList: " + clientList.size());
+// if (clientList != null && clientList.size() == 1) {
+// Object[] data = clientList.get(0);
+// clientName = StringUtil.safeTrimObj(data[0]);
+//
+// } else {
+// clientName = "UNKNOWN";
+// }
+// }
+//
+// // cutPos = StringUtil.getPositionSearchString(clientIP, '.', 3);
+// //
+// // if (cutPos != -1) {
+// // clientNummer = clientIP.substring(cutPos);
+// // ipBereich = clientIP.substring(0, cutPos);
+// // System.out.println("ipBereich " + ipBereich);
+// // clientName = "MDERF" + clientNummer;
+// // }
+//
+//
+// return clientName;
+// }
+
+ default:
+ break;
+ }
+ } catch (final Exception e) {
+ e.printStackTrace();
+ }
+ return null;
+ }
+
+ public static String getInetAddress() {
+ String adr = null;
+
+ try {
+ adr = InetAddress.getByName(HttpSessionAccess.getCurrentRequest().getRemoteAddr()).getHostName();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return adr;
+ }
+
+ /**
+ * Function to return the Servers IP
+ * @return Server IP
+ */
+ public static String getServerIP(){
+ try {
+
+ String serverIP = null;
+ String isDocker = System.getenv("ISDOCKER");
+
+ if (!StringUtil.safeIsBlank(isDocker) && isDocker.equalsIgnoreCase("true")) {
+ serverIP = InetAddress.getByName(getServerHostname()).getHostAddress();
+ } else {
+ serverIP = InetAddress.getLocalHost().getHostAddress();
+ }
+
+
+ return serverIP;
+ } catch (UnknownHostException e) {
+ e.printStackTrace();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return "";
+ }
+
+ /**
+ * Function to return the ServerHostname
+ * @return Server Hostname
+ */
+ public static String getServerHostname(){
+ try {
+ String hostname = null;
+
+ String isDocker = System.getenv("ISDOCKER");
+
+ if (!StringUtil.safeIsBlank(isDocker) && isDocker.equalsIgnoreCase("true")) {
+ hostname = System.getenv("HOSTNAME");
+
+ } else {
+ hostname = InetAddress.getLocalHost().getHostName();
+ }
+
+ if (hostname.indexOf(".") != -1) {
+ hostname = hostname.substring(0, hostname.indexOf("."));
+ }
+
+ return hostname;
+ } catch (UnknownHostException e) {
+ e.printStackTrace();
+ }
+ return "";
+ }
+
+ /**
+ * Return activ HttpSession
+ *
+ * @return HttpSession
+ */
+ public static HttpSession getHttpSession() {
+ HttpSession httpSession = null;
+ try {
+ httpSession = HttpSessionAccess.getCurrentHttpSession();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return httpSession;
+ }
+
+
+// /**
+// * Return SessionType
+// *
+// * @return SessionType
+// */
+// public static SessionTyp getServerSessionType() {
+// SessionTyp sessionType = SessionTyp.PORTAL_SESSION;
+//
+// try {
+//
+// String serverName = getServerHostname();
+//
+// if (serverName != null) {
+// if (serverName.startsWith("NESAS")) {
+// sessionType = SessionTyp.PORTAL_SESSION;
+// } else {
+// sessionType = SessionTyp.CLIENT_SESSION;
+// }
+// }
+//
+// } catch (Exception e) {
+// e.printStackTrace();
+// }
+// return sessionType;
+// }
+
+ /**
+ * Return SessionID
+ * @return SessionID
+ */
+ public static String getHttpSessionID() {
+ return HttpSessionAccess.getCurrentHttpSession().getId();
+ }
+
+ public static String getRootPath() {
+ String rootPath = null;
+ try {
+ rootPath = HttpSessionAccess.getServletContext().getRealPath("/");
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return rootPath;
+ }
+
+ /**
+ * @return gibt den Namen des Tomcats zurück, z.B. GWPTESTTC1
+ */
+ public static String getSessionName() {
+ String id = null;
+ try {
+ id = HttpSessionAccess.getCurrentHttpSession().getId();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ if (id != null && id.indexOf(".") != -1) {
+ id = id.substring(id.indexOf(".")+1);
+ } else {
+ id = "";
+ }
+ return id;
+ }
+
+ /**
+ * Resolves the hostname of the IP by the DNS, if not possible by the secondDNS
+ * If this isn't possible the IP itself is the result
+ * @param dns Primary DNS
+ * @param secondDNS Secondary DNS
+ * @param ip IP-Adress
+ * @return Hostname of the IP-Adress, if not possible the Adress itself
+ */
+ public static String getNameByIP(final String dns, final String secondDNS, final String ip) {
+ try {
+ //Splitte the IP in ihre Oktetten
+ final List oktetten = Arrays.stream(ip.split(Pattern.quote("."))).collect(Collectors.toList());
+
+ //Vertausche the Oktetten
+ Collections.reverse(oktetten);
+
+ //Bilde aus den Oktetten die Reverse-Lookup-Adresse
+ final String reverseLookupIP = oktetten.stream().collect(Collectors.joining(".")) + ".in-addr.arpa";
+
+ //PTR ist der DNS-Typ für Reverse Lookups (https://www.ionos.de/digitalguide/hosting/hosting-technik/ptr-record/)
+ final Lookup l = new Lookup(reverseLookupIP, Type.PTR);
+
+ //Resolver für den Primary DNS
+ {
+ final SimpleResolver sp = new SimpleResolver(dns);
+ sp.setTimeout(Duration.ofSeconds(5l));
+ l.setResolver(sp);
+ final Record[] records = l.run();
+
+ if (records != null) {
+ for (final Record r : records) {
+ final String target = (((PTRRecord) r).getTarget().getLabelString(0));
+ return target;
+ }
+ }
+ }
+ System.out.println("Primary DNS (" + dns + ") failed reversing: \"" + ip + "\"");
+
+ //Falls nicht gefunden wird und es einen Secondary DNS gibt:
+ if (secondDNS != null && !secondDNS.trim().isEmpty()) {
+ final SimpleResolver sp2 = new SimpleResolver(secondDNS);
+ sp2.setTimeout(Duration.ofSeconds(5l));
+ l.setResolver(sp2);
+ final Record[] records2 = l.run();
+
+ if (records2 != null) {
+ for (final Record r : records2) {
+ final String target = (((PTRRecord) r).getTarget().getLabelString(0));
+ return target;
+ }
+ }
+ }
+ System.out.println("Secondary DNS (" + secondDNS + ") failed reversing: \"" + ip + "\"");
+ } catch (final Throwable e) {
+ e.printStackTrace();
+ }
+ System.out.println("Returning\"" + ip + "\" as fallback");
+ //Als Fallback wir die IP-Adresse zurückgegeben
+ return ip;
+ }
+
+ /**
+ * Wandelt einen Hostnamen in einen LFS-Hostnamen um, für Mediamarkt Göttingen
+ * @param hostname
+ * @return GMM + PC (1) oder Notebook (2) + 4 stellige Nummer
+ */
+ public static String getLFSNameForGoettingenHostname(String hostname) {
+ try {
+ if (hostname.contains(".")) {
+ hostname = hostname.substring(0, hostname.indexOf('.'));
+ }
+
+ final int length = hostname.length();
+
+ final String p1 = "GMM";
+ final String wksOrnob = hostname.substring(length - 7, length - 4).toUpperCase();
+ String p2 = "";
+ if (wksOrnob.equals("WKS")) {
+ p2 = "1";
+ } else if (wksOrnob.equals("NOB")) {
+ p2 = "2";
+ } else {
+ throw new IllegalArgumentException("PC type of hostname \"" + hostname + "\" must be either wks or nob, but it's: \"" + wksOrnob + "\"");
+ }
+
+ final String p3 = hostname.substring(length - 4);
+ try {
+ Integer.parseInt(p3);
+ } catch (final Exception e) {
+ throw new IllegalArgumentException("PC number of hostname \"" + hostname + "\" must be a number with 4 digits, but it's: \"" + hostname.substring(length - 4) + "\"");
+ }
+
+ return p1 + p2 + p3;
+ } catch (final Exception e) {
+ System.out.println("Hostname: \"" + hostname + "\"");
+ e.printStackTrace();
+ }
+ return hostname;
+ }
+
+ /**
+ * Check if IP is within an Subnet defined by Network Address and Network Mask
+ * Via: https://stackoverflow.com/a/54514071/3123870
+ * @param ip
+ * @param net
+ * @param mask
+ * @return
+ */
+ public static final boolean isIpInSubnet(final String ip, final String net, final int prefix) {
+ try {
+ final byte[] ipBin = java.net.InetAddress.getByName(ip).getAddress();
+ final byte[] netBin = java.net.InetAddress.getByName(net).getAddress();
+ if (ipBin.length != netBin.length) {
+ return false;
+ }
+ int p = prefix;
+ int i = 0;
+ while (p >= 8) {
+ if (ipBin[i] != netBin[i]) {
+ return false;
+ }
+ ++i;
+ p -= 8;
+ }
+ final int m = (65280 >> p) & 255;
+ if ((ipBin[i] & m) != (netBin[i] & m)) {
+ return false;
+ }
+
+ return true;
+ } catch (final Throwable t) {
+ return false;
+ }
+ }
+
+
+ /**
+ * Resolves the Hostname of a Goettingen IP via Mediamarkt DNS
+ * @param IP
+ * @return
+ */
+ public static String getGoettingenHostname(final String ip) {
+ return getNameByIP("10.162.192.2", "10.162.192.4", ip);
+ }
+
+}
diff --git a/src/main/java/de/tvo/tools/Exceptions.java b/src/main/java/de/tvo/tools/Exceptions.java
index 58416fa..f3e278f 100644
--- a/src/main/java/de/tvo/tools/Exceptions.java
+++ b/src/main/java/de/tvo/tools/Exceptions.java
@@ -65,14 +65,14 @@ public class Exceptions {
return new StringBuilder(new Timestamp(System.currentTimeMillis()).toString()).append(" - ").append(new Exception().getStackTrace()[1].toString());
}
- public final static String prettyPrintGeisException(Throwable e, boolean consolePrint){
+ public final static String prettyPrintTvoException(Throwable e, boolean consolePrint){
StringBuilder builder = new StringBuilder(e.getClass().getSimpleName());
if (e.getMessage() != null) {
builder.append("\t\tMessage: \"").append(e.getMessage()).append('\"');
}
- for (StackTraceElement peter : e.getStackTrace()) {
- if (peter.getClassName().startsWith("de.geis") || peter.getClassName().startsWith("managedbeans")) {
- builder.append("\n\t").append(peter);
+ for (StackTraceElement petter : e.getStackTrace()) {
+ if (petter.getClassName().startsWith("de.tvo") || petter.getClassName().startsWith("managedbeans")) {
+ builder.append("\n\t").append(petter);
}
}
if (consolePrint) {
diff --git a/src/main/java/de/tvo/tools/NumericUtil.java b/src/main/java/de/tvo/tools/NumericUtil.java
new file mode 100644
index 0000000..7544127
--- /dev/null
+++ b/src/main/java/de/tvo/tools/NumericUtil.java
@@ -0,0 +1,248 @@
+package de.tvo.tools;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.text.DecimalFormat;
+import java.util.Random;
+import java.util.regex.Pattern;
+
+public class NumericUtil {
+
+ public NumericUtil() {
+
+ }
+
+ public static boolean checkGanzZahl(double value){
+ //Fuern A....!!!!!
+ //return Math.abs(value) < Float.MIN_VALUE;
+
+ return (value % 1 == 0);
+ }
+
+ /**
+ * Returns random double between low and high
+ *
+ * @param low
+ * lowest possible
+ * @param high
+ * highest possible
+ * @return random Double between low and high
+ */
+ public static Double myRandom(double low, double high) {
+ return new Random().nextDouble() * (high - low) + low;
+ }
+
+ /**
+ * Returns random Integer between low and high
+ *
+ * @param low
+ * lowest possible
+ * @param high
+ * highest possible
+ * @return Integer between low and high
+ */
+ public static int myRandom(int low, int high) {
+ return new Random().nextInt(high - low) + low;
+ }
+
+ /**
+ * Returns boolean numeric Int is true or false
+ *
+ * @param number
+ * Integer
+ * @return
+ */
+ public static boolean isNumericInt(String number) {
+ boolean numeric = false;
+
+ if (number != null && number.matches("[\\+\\-]{0,1}[0-9]+$")) {
+ numeric = true;
+ }
+
+ return numeric;
+ }
+
+ /**
+ *
+ * Check If a String Is a Numeric
+ *
+ * @return true if numeric
+ */
+ public static boolean isNumeric(String str) {
+ return StringUtil.safeTrimObjWithReplace(str).replace(",", ".").matches("-?\\d+(\\.\\d+)?");
+ }
+
+ /**
+ * Returns boolean numeric Double is true or false
+ *
+ * @param number
+ * Double
+ * @return
+ */
+ public static boolean isNumericDouble(String number) {
+ boolean numeric = false;
+
+ if (number != null && number.matches("^[\\+\\-]{0,1}[0-9]+[\\.\\,]{1}[0-9]+$")) {
+ numeric = true;
+ }
+ return numeric;
+ }
+
+ public static Float formatStringToNumericFloat(Object zahl) {
+ return Float.valueOf(formatStringToNumeric(zahl, "Float").toString());
+ }
+
+ public static Object formatStringToNumeric(Object zahlobj, String type) {
+ return formatStringToNumericWithScale(zahlobj, type, 2, false);
+ }
+
+ public static Object formatStringToNumericWeight(Object zahlobj, String type) {
+ return formatStringToNumericWithScale(zahlobj, type, 3, false);
+ }
+
+ public static Object formatStringToNumericWithScale(Object zahlobj, String type, int scale) {
+ return formatStringToNumericWithScale(zahlobj, type, scale, false);
+ }
+
+ public static Object formatStringToNumericWithScale(Object zahlobj, String type, int scale, boolean negativ) {
+ return formatStringToNumericWithScale(zahlobj, type, scale, negativ, 0, null);
+ }
+
+ public static Object formatStringToNumericWithScale(Object zahlobj, String type, int scale, boolean negativ,
+ int decimalPlace, String kommapunkt) {
+ Object result = null;
+ String zahl = null;
+ if (zahlobj == null)
+ return 0;
+
+ if (type == null)
+ return 0;
+
+ System.out.println("Type: " + type);
+
+ if (type.equals("String")) {
+ return zahlobj;
+ }
+
+ if (scale < 1 || scale > 12)
+ scale = 2;
+ try {
+ zahl = zahlobj.toString().trim();
+
+ if (negativ == false) {
+ if (zahl.startsWith("-"))
+ return 0;
+ }
+
+ zahl = StringUtil.replaceAllWithReplace(zahl, ",", ".");
+
+ try {
+ BigDecimal decimal = new BigDecimal(zahl);
+
+ zahl = decimal.toString();
+ } catch (Exception e) {
+ return 0;
+ }
+ System.out.println("formatStringToNumericWithScale: " + zahl);
+
+ if (checkNummerischAll(zahl) == false)
+ return 0;
+
+ Object nachkomma = StringUtil.fillString("0", decimalPlace, "0", "right");
+
+ DecimalFormat format = new DecimalFormat("#0." + nachkomma);
+
+ if (type.equalsIgnoreCase("Integer")) {
+ BigDecimal dzahl = new BigDecimal(zahl);
+ dzahl = dzahl.setScale(0, RoundingMode.HALF_UP);
+ result = dzahl.intValue();
+ } else if (type.equalsIgnoreCase("Long")) {
+ BigDecimal dzahl = new BigDecimal(zahl);
+ dzahl = dzahl.setScale(0, RoundingMode.HALF_UP);
+ result = dzahl.longValue();
+ } else if (type.equalsIgnoreCase("Double")) {
+ BigDecimal dzahl = new BigDecimal(zahl);
+ dzahl = dzahl.setScale(scale, RoundingMode.HALF_UP);
+
+ if (decimalPlace != 0) {
+ result = format.format(dzahl);
+ } else {
+ result = dzahl.doubleValue();
+ }
+ } else if (type.equalsIgnoreCase("Float")) {
+ BigDecimal dzahl = new BigDecimal(zahl);
+ dzahl = dzahl.setScale(scale, RoundingMode.HALF_UP);
+
+ if (decimalPlace != 0) {
+ result = format.format(dzahl);
+ } else {
+ result = dzahl.floatValue();
+ }
+
+ } else {
+ result = zahl.toString();
+ }
+
+ if (!StringUtil.safeIsBlank(kommapunkt))
+ result = StringUtil.replaceAllWithReplace(result.toString(), ".", kommapunkt);
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ // LogHandler.logError("Tools", e, "formatStringToNumeric", "");
+ return null;
+ }
+ System.out.println("DA: " + result);
+
+ return result;
+ }
+
+ static public boolean checkNummerischAll(Object datenString) {
+ Pattern regularDigits = Pattern.compile("((-|\\+)?[0-9]+(\\.[0-9]+)?)+");
+ BigDecimal decimal = null;
+
+ try {
+ Double zahl = Double.valueOf(datenString.toString().replace(",", "."));
+ decimal = new BigDecimal(zahl);
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ return false;
+ }
+
+ System.out.println(decimal);
+ if (regularDigits.matcher(decimal.toString()).matches()) {
+ return true;
+ }
+ return false;
+ }
+
+ public static String getFormatFromNumeric(Object numeric) {
+ String regexDecimal = "^[1-9]\\d*((\\.|\\,)\\d+)?$";
+ String regexInteger = "^[1-9]\\d*$";
+ String regexDouble = regexDecimal + "|" + regexInteger;
+
+ if (numeric.toString().matches(regexInteger)) {
+ return "INTEGER";
+ } else if (numeric.toString().matches(regexDouble)) {
+ return "DOUBLE";
+ } else {
+ return "No Numeric";
+ }
+ }
+
+ public static int getAlwaysRoundUp(double value) {
+ Double result = 0.0;
+ result = Math.ceil(value);
+
+ return result.intValue();
+ }
+
+ /**
+ * Round given double to max. 2 decimals
+ * @param val
+ * @return rounded double
+ */
+ public static double roundTo2Decimals(double val) {
+ return Math.round(val*100.0)/100.0;
+ }
+}
diff --git a/src/main/java/de/tvo/tools/SearchReplaceObj.java b/src/main/java/de/tvo/tools/SearchReplaceObj.java
new file mode 100644
index 0000000..98f240c
--- /dev/null
+++ b/src/main/java/de/tvo/tools/SearchReplaceObj.java
@@ -0,0 +1,30 @@
+package de.tvo.tools;
+
+public class SearchReplaceObj {
+
+ private String m_search;
+ private String m_replace;
+
+ public SearchReplaceObj(String search, String replace) {
+ this.m_search = search;
+ this.m_replace = replace;
+ }
+
+ public String getSearch() {
+ return m_search;
+ }
+
+ public void setSearch(String search) {
+ m_search = search;
+ }
+
+ public String getReplace() {
+ return m_replace;
+ }
+
+ public void setReplace(String replace) {
+ m_replace = replace;
+ }
+
+
+}
diff --git a/src/main/java/de/tvo/tools/StringUtil.java b/src/main/java/de/tvo/tools/StringUtil.java
index be4700f..127481f 100644
--- a/src/main/java/de/tvo/tools/StringUtil.java
+++ b/src/main/java/de/tvo/tools/StringUtil.java
@@ -1,10 +1,15 @@
package de.tvo.tools;
import java.nio.charset.Charset;
+import java.nio.charset.CharsetEncoder;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.xmlbeans.impl.common.Levenshtein;
public class StringUtil {
@@ -20,7 +25,7 @@ public class StringUtil {
*/
public static void main(String[] args) {
- // TEST
+
}
/**
@@ -332,6 +337,18 @@ public class StringUtil {
return result;
}
+ /**
+ * Check Webadresse
+ * @param webadresse
+ * @return True = valid; or False = not valid
+ */
+ public static boolean checkWebAdresse(String webadresse) {
+ String regex = "^(https?:\\/\\/)?([\\w.-]+(?:\\.[\\w\\.-]+)+)(:[0-9]{1,5})?(\\/[^\\s]*)?$";
+ Pattern pattern = Pattern.compile(regex);
+ Matcher matcher = pattern.matcher(webadresse);
+ return(matcher.matches());
+ }
+
public static List checkIfTextContainsMails(String text) {
List correctEmails = new ArrayList<>();
@@ -434,7 +451,109 @@ public class StringUtil {
return sb.toString();
}
-
+ /**
+ * Uppercase the word and the 'ß' stays.
+ * Normally when used toUppercase() it will change to 'SS'
+ *
+ * @param string
+ * @return
+ */
+ public static String toUpperSpecialCharacter(String s) {
+ StringBuilder sb = new StringBuilder();
+ for(char c : s.toCharArray()) {
+ if (c != 'ß') {
+ c = Character.toUpperCase(c);
+ }
+ sb.append(c);
+ }
+
+ return sb.toString();
+ }
+
+ /**
+ * Sucht per Levenshtein den ähnlichsten String für searchString aus der searchList
+ * @param searchString - Zu suchender String
+ * @param searchList - List aus String
+ * @return den ähnlichsten String
+ */
+ public static String findClosestMatch(final String searchString, final List searchList) {
+ return searchList.stream()
+ .sorted((a, b) -> Levenshtein.distance(searchString, a) - Levenshtein.distance(searchString, b))
+ .findFirst()
+ .orElse(null);
+ }
+
+ /**
+ * Sucht per Levenshtein den ähnlichsten String für searchString aus der searchList ohne Beachtung von Groß- und Kleinschreibung
+ * @param searchString - Zu suchender String
+ * @param searchList - List aus String
+ * @return den ähnlichsten String
+ */
+ public static String findClosestMatchIgnoreCase(final String searchString, final List searchList) {
+ return searchList.stream()
+ .sorted((a, b) -> Levenshtein.distance(searchString.toLowerCase(), a.toLowerCase()) - Levenshtein.distance(searchString.toLowerCase(), b.toLowerCase()))
+ .findFirst()
+ .orElse(null);
+ }
+
+ /**
+ * Sucht per Levenshtein den ähnlichsten String zu einem der searchStrings aus der searchList ohne Beachtung von Groß- und Kleinschreibung
+ * @param searchString1 - Zu suchender String
+ * @param searchString2 - Zu suchender String
+ * @param searchList - List aus String
+ * @return den ähnlichsten String
+ */
+ public static String findClosestMatchIgnoreCase(final String searchString1, final String searchString2, final List searchList) {
+ String match1 = searchList.stream()
+ .sorted((a, b) -> Levenshtein.distance(searchString1.toLowerCase(), a.toLowerCase()) - Levenshtein.distance(searchString1.toLowerCase(), b.toLowerCase()))
+ .findFirst()
+ .orElse(null);
+
+ if (searchString2 == null || searchString2.trim().isEmpty()) {
+ return match1;
+ }
+
+ String match2 = searchList.stream()
+ .sorted((a, b) -> Levenshtein.distance(searchString2.toLowerCase(), a.toLowerCase()) - Levenshtein.distance(searchString2.toLowerCase(), b.toLowerCase()))
+ .findFirst()
+ .orElse(null);
+
+ int distance1 = Levenshtein.distance(searchString1.toLowerCase(), match1.toLowerCase());
+ int distance2 = Levenshtein.distance(searchString2.toLowerCase(), match2.toLowerCase());
+
+ if (distance1 <= distance2) {
+ return match1;
+ }
+ return match2;
+ }
+
+ /**
+ * @param converToCamelCase - to converted string
+ * @return String in Camel Case
+ */
+ public static String getCamelCase(String converToCamelCase) {
+ if (converToCamelCase != null && !converToCamelCase.isEmpty()) {
+ StringBuilder newString = new StringBuilder(converToCamelCase.length());
+ for (final String StringWort : converToCamelCase.split("\\Q \\E")) {
+ if (newString.length() != 0) {
+ newString.append(' ');
+ }
+ switch (StringWort.length()) {
+ case 0:
+ break;
+ case 1:
+ newString.append(Character.toUpperCase(StringWort.charAt(0)));
+ break;
+ default:
+ newString.append(Character.toUpperCase(StringWort.charAt(0)));
+ newString.append(StringWort.substring(1).toLowerCase());
+ break;
+ }
+ }
+ converToCamelCase = newString.toString();
+ }
+ return converToCamelCase;
+ }
/**
* Check if the AS/400 can handle the string
@@ -445,5 +564,80 @@ public class StringUtil {
return Charset.forName("IBM01141").newEncoder().canEncode(str);
}
+ /**
+ * Removes all non CP273 chars from the string
+ * @param str
+ * @return str without of non CP273 chars
+ */
+ public static String removeAllNonCP273Characters(final String str) {
+ CharsetEncoder cp273encoder = Charset.forName("IBM01141").newEncoder();
+ return str
+ .chars()
+ .mapToObj(i -> "" + (char) i)
+ .filter(i -> cp273encoder.canEncode(i))
+ .collect(Collectors.joining());
+ }
+
+ /**
+ * Replaces all non CP273 chars from the string
+ * @param str
+ * @return str with ASCii instead of non CP273 chars
+ */
+ public static String replaceAllNonCP273CharactersWithAscii(final String str) {
+ CharsetEncoder cp273encoder = Charset.forName("IBM01141").newEncoder();
+ String result = "";
+ for (char ch : str.toCharArray()) {
+ if(cp273encoder.canEncode(ch)) {
+ result += ""+ch;
+ } else {
+ result += StringUtils.stripAccents(""+ch);
+ }
+ }
+ return result;
+ }
+
+ /**
+ * convertToUpperCaseExceptSharpS
+ * @param input
+ * @return
+ */
+ public static String convertToUpperCaseExceptSharpS(String input) {
+ if (input == null) {
+ return null;
+ }
+ StringBuilder result = new StringBuilder();
+ for (int i = 0; i < input.length(); i++) {
+ char currentChar = input.charAt(i);
+ if (currentChar == 'ß') {
+ result.append(currentChar);
+ } else {
+ result.append(Character.toUpperCase(currentChar));
+ }
+ }
+ return result.toString();
+ }
+ /**
+ * replaceAllFromList
+ * @param text
+ * @return
+ */
+ public static String replaceAllFromList(String text, boolean trim) {
+ String result = null;
+ // Search Replace List
+ List searchReplaceList = new ArrayList();
+ searchReplaceList.add(new SearchReplaceObj("–", "-"));
+
+
+ if (trim) {
+ result = text.trim();
+ } else {
+ result = text;
+ }
+ for (SearchReplaceObj searchReplaceObj: searchReplaceList) {
+ result = StringUtil.replaceAllWithReplace(result, searchReplaceObj.getSearch(), searchReplaceObj.getReplace());
+ }
+
+ return result;
+ }
}
diff --git a/src/main/java/de/tvo/tools/XMLUtils.java b/src/main/java/de/tvo/tools/XMLUtils.java
deleted file mode 100644
index 1033e93..0000000
--- a/src/main/java/de/tvo/tools/XMLUtils.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package de.tvo.tools;
-
-import java.io.StringReader;
-import java.io.StringWriter;
-
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.transform.Transformer;
-import javax.xml.transform.TransformerException;
-import javax.xml.transform.TransformerFactory;
-import javax.xml.transform.dom.DOMSource;
-import javax.xml.transform.stream.StreamResult;
-
-import org.w3c.dom.Document;
-import org.xml.sax.InputSource;
-
-public class XMLUtils {
-
- public static String convertXMLDocumentToString(Document doc) {
- TransformerFactory tf = TransformerFactory.newInstance();
- Transformer transformer;
- try {
- transformer = tf.newTransformer();
- // below code to remove XML declaration
- // transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
- StringWriter writer = new StringWriter();
- transformer.transform(new DOMSource(doc), new StreamResult(writer));
- String output = writer.getBuffer().toString();
- return output;
- } catch (TransformerException e) {
- e.printStackTrace();
- return null;
- }
-
- }
-
- public static Document convertStringToXMLDocument(String xmlStr) {
- DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
- DocumentBuilder builder;
- try {
- builder = factory.newDocumentBuilder();
- Document doc = builder.parse(new InputSource(new StringReader(xmlStr)));
- return doc;
- } catch (Exception e) {
- e.printStackTrace();
- return null;
- }
- }
-}
diff --git a/src/main/java/de/tvo/toolset/PropertiesHandler.java b/src/main/java/de/tvo/toolset/PropertiesHandler.java
new file mode 100644
index 0000000..368df7a
--- /dev/null
+++ b/src/main/java/de/tvo/toolset/PropertiesHandler.java
@@ -0,0 +1,446 @@
+package de.tvo.toolset;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Set;
+import java.util.Vector;
+
+/**
+ * DE:
+ *
+ * EN:
+ *
+ *
+ * Program changes
+ * **************************************************************************************
+ * Date * Ticket * KonzFirm * Responsible * programmer *
+ * Change *
+ * **************************************************************************************
+ *
+ * @author VogelT
+ * @version 1.0
+ *
+ */
+
+
+
+
+public class PropertiesHandler {
+ private Vector