diff --git a/.externalToolBuilders/build.xml [Builder].launch b/.externalToolBuilders/build.xml [Builder].launch
index 55629c1..4b4e2ff 100644
--- a/.externalToolBuilders/build.xml [Builder].launch	
+++ b/.externalToolBuilders/build.xml [Builder].launch	
@@ -4,10 +4,10 @@
     <booleanAttribute key="org.eclipse.ant.ui.DEFAULT_VM_INSTALL" value="false"/>
     <booleanAttribute key="org.eclipse.debug.core.ATTR_FORCE_SYSTEM_CONSOLE_ENCODING" value="false"/>
     <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
-        <listEntry value="/geis_shared/build.xml"/>
+        <listEntry value="/web_shared"/>
     </listAttribute>
     <listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
-        <listEntry value="1"/>
+        <listEntry value="4"/>
     </listAttribute>
     <booleanAttribute key="org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND" value="true"/>
     <booleanAttribute key="org.eclipse.jdt.launching.ATTR_ATTR_USE_ARGFILE" value="false"/>
diff --git a/pom.xml b/pom.xml
index 8dc387c..a1c459e 100644
--- a/pom.xml
+++ b/pom.xml
@@ -35,7 +35,80 @@
 		    <groupId>org.eclnt</groupId>
 		    <artifactId>eclntjsfserverRISC_jakarta</artifactId>
 		    <version>${cc.version}</version>
-		</dependency>        
+		</dependency>   
+		<dependency> <!-- log4j bridge -->
+			<groupId>org.apache.logging.log4j</groupId>
+			<artifactId>log4j-core</artifactId>
+			<version>2.17.0</version>
+		</dependency>
+		<dependency>
+			<groupId>log4j</groupId>
+			<artifactId>log4j</artifactId>
+			<version>1.2.17</version>
+		</dependency>
+		<dependency>
+			<groupId>com.google.code.gson</groupId>
+			<artifactId>gson</artifactId>
+			<version>2.8.5</version>
+		</dependency>     
+		<dependency>
+		    <groupId>org.hibernate</groupId>
+		    <artifactId>hibernate-core-jakarta</artifactId>
+		    <version>5.6.15.Final</version>
+		</dependency>
+		<dependency>
+		    <groupId>org.apache.xmlbeans</groupId>
+		    <artifactId>xmlbeans</artifactId>
+		    <version>2.6.0</version>
+			<exclusions>
+				<exclusion>
+					<artifactId>stax-ex</artifactId>
+					<groupId>org.jvnet.staxex</groupId>
+				</exclusion>
+				<exclusion>
+					<artifactId>stax-api</artifactId>
+					<groupId>stax</groupId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+		<dependency>
+		    <groupId>org.apache.xmlbeans</groupId>
+		    <artifactId>xmlbeans</artifactId>
+		    <version>5.2.0</version>
+		</dependency>
+		<dependency>
+		    <groupId>org.mariadb.jdbc</groupId>
+		    <artifactId>mariadb-java-client</artifactId>
+		    <version>3.1.3</version>
+		</dependency>
+		<dependency>
+			<groupId>
+				xerces</groupId>
+			<artifactId>xercesImpl</artifactId>
+			<version>2.12.2</version>
+			<exclusions>
+            <exclusion>
+                <artifactId>xml-apis</artifactId>
+                <groupId>
+						xml-apis</groupId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+		<dependency>
+			<groupId>org.owasp.esapi</groupId>
+			<artifactId>esapi</artifactId>
+			<version>2.5.3.1</version>
+	        <exclusions>
+	            <exclusion>
+	                <artifactId>xml-apis</artifactId>
+	                <groupId>xml-apis</groupId>
+				</exclusion>
+	            <exclusion>
+	                <artifactId>xml-apis</artifactId>
+	                <groupId>xml-apis-ext</groupId>
+				</exclusion>
+			</exclusions>
+		</dependency>
 		<!-- optional: addon pacakges -->
 		<!--
 		<dependency>
diff --git a/src/main/java/de/tvo/database/DBHandler.java b/src/main/java/de/tvo/database/DBHandler.java
new file mode 100644
index 0000000..68b8566
--- /dev/null
+++ b/src/main/java/de/tvo/database/DBHandler.java
@@ -0,0 +1,1956 @@
+package de.tvo.database;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Vector;
+
+import javax.naming.InitialContext;
+import javax.naming.NamingException;
+import javax.sql.DataSource;
+
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.Transaction;
+import org.hibernate.cfg.Configuration;
+import org.hibernate.query.NativeQuery;
+import org.hibernate.query.Query;
+
+import de.tvo.global.PreparedStatementData;
+import de.tvo.reflection.MyObject;
+import de.tvo.tools.Exceptions;
+import de.tvo.tools.StringUtil;
+import de.tvo.toolset.DBTools;
+import de.tvo.toolset.DBTools.SchemataENUM;
+import jakarta.persistence.PersistenceException;
+
+public class DBHandler {
+
+	/**
+	 * Map for all the SessionPools for the time the App is up
+	 */
+	private final static HashMap<SchemataENUM, SessionFactory> SESSIONPOOLMAP = new HashMap<SchemataENUM, SessionFactory>();
+
+	/**
+	 * Static block to initilize SessionPoolMap. This is a ClassInitilizer, so only
+	 * called once.
+	 */
+	static {
+		for (SchemataENUM sEnum : SchemataENUM.values()) {
+			try {
+				SESSIONPOOLMAP.put(sEnum, new Configuration().configure("META-INF/" + sEnum.name() + ".cfg.xml").buildSessionFactory());
+			}
+			catch (Throwable e) {
+				try {
+					if (e instanceof org.hibernate.service.spi.ServiceException && e.getMessage().equals("Unable to create requested service [org.hibernate.engine.jdbc.env.spi.JdbcEnvironment]")) {
+						System.out.println("Unable to create requested service [org.hibernate.engine.jdbc.env.spi.JdbcEnvironment], [" + sEnum.name() +"] is probably not bound in this Context.");
+					} else {
+						e.printStackTrace();
+						System.out.println("Hibernateconfiguration is missing for: " + sEnum.name() + ". Please create a valid META-INF/" + sEnum.name() + ".cfg.xml.");
+					}
+				} catch (Exception ex) {
+					ex.printStackTrace();
+				}
+			}
+		}
+	}
+
+	// ------------------------- PreparedStatement -----------------------
+
+	private final SessionFactory sessionFactory;
+
+	/**
+	 * Get PreparedStatement for sql
+	 *
+	 *
+	 * @param sql
+	 * @return PreparedStatement
+	 * @throws Exception
+	 */
+	public List<Object[]> getPreparedStatementSelectWithFeedback(CharSequence sql, PreparedStatementData parameterMap) throws Exception {
+		List<Object[]> dataObjList = new ArrayList<>();
+		try (Connection con = getConnection(); PreparedStatement ps = con.prepareStatement(sql.toString());) {
+			Iterator<Integer> it = parameterMap.keySet().iterator();
+			while (it.hasNext()) {
+				Integer key = it.next();
+				Object data = parameterMap.get(key);
+				ps.setObject(key, data);
+			}
+			try (ResultSet resultSet = ps.executeQuery()) {
+				int countedSelect = resultSet.getMetaData().getColumnCount();
+				while (resultSet.next()) {
+					Object[] array = new Object[countedSelect];
+					for (int i = 1; i <= countedSelect; i++) {
+						array[i - 1] = resultSet.getObject(i);
+						
+					}
+					dataObjList.add(array);
+				}
+			}
+		}
+		catch (Exception e) {
+			throw e;
+		}
+		return dataObjList;
+	}
+
+	public List<Object[]> getPreparedStatementSelect(CharSequence sql, PreparedStatementData parameterMap) {
+		List<Object[]> dataObjList = new ArrayList<>();
+		try {
+			dataObjList = getPreparedStatementSelectWithFeedback(sql, parameterMap);
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+		}
+		return dataObjList;
+	}
+
+	/**
+	 * Execute prepared update statement
+	 *
+	 * @param sql
+	 *                   SQL String to be executed including placeholders
+	 * @param prepStData
+	 *                   PreparedStatementData to be filled into placeholders
+	 * @return number of affected rows or -1 in case of error
+	 */
+	public int execPreparedStatementUpdate(CharSequence sql, PreparedStatementData prepStData) {
+		try {
+			return execPreparedStatementUpdateWithFeedback(sql, prepStData);
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			return -1;
+		}
+	}
+
+	/**
+	 * Execute prepared update statement
+	 *
+	 * @param sql
+	 *                   SQL String to be executed including placeholders
+	 * @param prepStData
+	 *                   PreparedStatementData to be filled into placeholders
+	 * @return number of affected rows
+	 * @throws Exception
+	 */
+	public int execPreparedStatementUpdateWithFeedback(CharSequence sql, PreparedStatementData prepStData) throws Exception {
+		try (Connection conn = getConnection(); PreparedStatement prepSt = conn.prepareStatement(sql.toString());) {
+			Iterator<Integer> it = prepStData.keySet().iterator();
+			while (it.hasNext()) {
+				Integer key = it.next();
+				Object data = prepStData.get(key);
+				prepSt.setObject(key, data);
+			}
+			return prepSt.executeUpdate();
+		}
+	}
+
+	// ------------------------------ JDBC ------------------------------
+
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlBuilder
+	 *                   Select you want to execute
+	 * @param maxRows
+	 *                   Select First x Rows only
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 */
+	public List<Object[]> jdbcSelect(StringBuilder sqlBuilder, int maxRows) {
+		return jdbcSelect(sqlBuilder.append(" FETCH FIRST ").append(maxRows).append(" ROWS ONLY").toString());
+	}
+
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlBuffer
+	 *                  Select you want to execute
+	 * @param maxRows
+	 *                  Select First x Rows only
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 */
+	public List<Object[]> jdbcSelect(StringBuffer sqlBuffer, int maxRows) {
+		return jdbcSelect(sqlBuffer.append(" FETCH FIRST ").append(maxRows).append(" ROWS ONLY").toString());
+	}
+
+	// ---------------------------
+
+
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlBuffer
+	 *                  Select you want to execute
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 */
+	public List<Object[]> jdbcSelect(CharSequence sqlString) {
+		List<Object[]> result = new ArrayList<>();
+		try {
+			result = jdbcSelectWithFeedback(sqlString);
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+		}
+		return result;
+	}
+
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlString
+	 *                  Select you want to execute
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 * @throws SQLException
+	 */
+	public List<Object[]> jdbcSelectWithFeedback(CharSequence sqlString) throws SQLException {
+		List<Object[]> result = new ArrayList<>();
+		try (Connection con = getConnection(); Statement stmt = con.createStatement(); ResultSet res = stmt.executeQuery(sqlString.toString())) {
+			int countedSelect = res.getMetaData().getColumnCount();
+			while (res.next()) {
+				Object[] array = new Object[countedSelect];
+				for (int i = 1; i <= countedSelect; i++) {
+					array[i - 1] = res.getObject(i);
+					
+				}
+				result.add(array);
+			}
+		}
+		catch (SQLException e) {
+			throw e;
+		} 
+		return result;
+	}
+	
+	public static Object[][] buildObjectArray(ResultSet rs, int columnCount) {
+		return buildObjectArray(rs, columnCount, true);
+	}
+
+	/**
+	 * Bildet aus Resultset ObjectArray
+	 *
+	 * @param rs
+	 *                    Ergebnis der SQL
+	 * @param columnCount
+	 *                    Anzahl Spalten
+	 * @return SQL Ergebnis
+	 */
+	public static Object[][] buildObjectArray(ResultSet rs, int columnCount, boolean trim) {
+		try {
+			// Erst mal feststellen wieviele Zeilen das Result hat
+			int rowCount = 0;
+			Vector<Object> vec = new Vector<Object>();
+			// rs.first macht mit einer DB2 Probleme
+			// if(rs.first() == false) return new Object[0][columnCount];
+
+			while (rs.next()) {
+				Object[] oa = new Object[columnCount];
+				for (int i = 0; i < columnCount; i++) {
+					Object value = rs.getObject(i + 1);
+					if (value == null) {
+						value = new String("null");
+					}
+					if (trim) {
+						oa[i] = value.toString().trim();
+					}
+					else {
+						oa[i] = value.toString();
+					}
+				}
+				vec.add(oa);
+				rowCount++;
+			}
+			Object[][] data = new Object[rowCount][columnCount];
+			for (int rc = 0; rc < rowCount; rc++) {
+				Object[] oa = (Object[]) vec.get(rc);
+				for (int cc = 0; cc < columnCount; cc++) {
+					data[rc][cc] = oa[cc];
+				}
+			}
+			return data;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+		}
+		return new Object[0][columnCount];
+	}
+
+	
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * GeisJdbcArray, an Objectarray capable of JDBC numericDatatype Getters,
+	 * whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlBuffer
+	 *                  Select you want to execute
+	 * @return List of GeisJdbcArray, an Objectarray capable of JDBC numericDatatype
+	 *         Getters. Every ObjectArray is a item of the table. Array is sorted
+	 *         along the given SQL
+	 */
+//	public List<GeisJdbcArray> jdbcSelectExtended(CharSequence sqlString) {
+//		List<GeisJdbcArray> result = new ArrayList<>();
+//		try {
+//			result = jdbcSelectWithFeedbackExtended(sqlString);
+//		}
+//		catch (Exception e) {
+//			e.printStackTrace();
+//		}
+//		return result;
+//	}
+
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlBuffer
+	 *                  Select you want to execute
+	 * @param maxRows
+	 *                  Select First x Rows only
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 */
+	public List<Object[]> jdbcSelect(String sqlString, int maxRows) {
+		return jdbcSelect(new StringBuilder(sqlString).append(" FETCH FIRST ").append(maxRows).append(" ROWS ONLY").toString());
+	}
+
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlString
+	 *                  Select you want to execute
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 * @throws SQLException
+	 */
+	public List<HashMap<String, Object>> jdbcSelectAsMapWithFeedback(CharSequence sqlString) throws SQLException {
+		List<HashMap<String, Object>> result = new ArrayList<HashMap<String, Object>>();
+		try (Connection con = getConnection(); Statement stmt = con.createStatement(); ResultSet res = stmt.executeQuery(sqlString.toString())) {
+			int columnCount = res.getMetaData().getColumnCount();
+			List<String> headLines = new ArrayList<String>(columnCount);
+			for (int i = 1; i <= columnCount; i++) {
+				headLines.add(res.getMetaData().getColumnLabel(i));
+			}
+			HashMap<String, Object> currentItem;
+			while (res.next()) {
+				currentItem = new HashMap<String, Object>();
+				for (String headline : headLines) {
+					int index = headLines.indexOf(headline) + 1;
+						currentItem.put(headline, res.getObject(index));
+					
+					
+				}
+				result.add(currentItem);
+			}
+		}
+		catch (SQLException e) {
+			throw e;
+		} 
+		return result;
+	}
+
+	public List<HashMap<String, Object>> jdbcSelectAsMapWithFeedback(CharSequence sqlString, int timeout) throws Exception {
+		List<HashMap<String, Object>> result = new ArrayList<HashMap<String, Object>>();
+		try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
+			stmt.setQueryTimeout(timeout);
+
+			try (ResultSet res = stmt.executeQuery(sqlString.toString())) {
+				int columnCount = res.getMetaData().getColumnCount();
+				List<String> headLines = new ArrayList<String>(columnCount);
+				for (int i = 1; i <= columnCount; i++) {
+					headLines.add(res.getMetaData().getColumnLabel(i));
+				}
+				HashMap<String, Object> currentItem;
+				while (res.next()) {
+					currentItem = new HashMap<String, Object>();
+					for (String headline : headLines) {
+						int index = headLines.indexOf(headline) + 1;
+						currentItem.put(headline, res.getObject(index));
+						
+						
+					}
+					result.add(currentItem);
+				}
+			}
+			catch (SQLException e) {
+				throw e;
+			}
+		}
+		catch (SQLException e) {
+			throw e;
+		}
+		return result;
+	}
+
+//	public List<LinkedHashMap<String, Object>> jdbcSelectAsMapWithFeedbackAsLinkedMap(CharSequence sqlString, int timeout) throws SQLException {
+//		List<LinkedHashMap<String, Object>> result = new ArrayList<LinkedHashMap<String, Object>>();
+//		try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
+//			stmt.setQueryTimeout(timeout);
+//
+//			try (ResultSet res = stmt.executeQuery(sqlString.toString())) {
+//				int columnCount = res.getMetaData().getColumnCount();
+//				List<String> headLines = new ArrayList<String>(columnCount);
+//				for (int i = 1; i <= columnCount; i++) {
+//					headLines.add(res.getMetaData().getColumnLabel(i));
+//				}
+//				LinkedHashMap<String, Object> currentItem;
+//				while (res.next()) {
+//					currentItem = new LinkedHashMap<String, Object>();
+//					for (String headline : headLines) {
+//						int index = headLines.indexOf(headline) + 1;
+//						if (res.getObject(index) instanceof AS400JDBCClobLocator) {
+//							currentItem.put(headline, IOUtils.toString(res.getClob(index).getCharacterStream()));
+//						} else {
+//							currentItem.put(headline, res.getObject(index));
+//						}
+//						
+//					}
+//					result.add(currentItem);
+//				}
+//			}
+//			catch (SQLException e) {
+//				throw e;
+//			} catch (IOException e) {
+//				e.printStackTrace();
+//			}
+//		}
+//		catch (SQLException e) {
+//			throw e;
+//		}
+//		return result;
+//	}
+
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlString
+	 *                  Select you want to execute
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 * @throws SQLException
+	 */
+	public List<HashMap<String, Object>> jdbcPreparedSelectAsMapWithFeedback(CharSequence sqlString, PreparedStatementData parameterMap) throws SQLException {
+		List<HashMap<String, Object>> result = new ArrayList<HashMap<String, Object>>();
+		try (Connection con = getConnection(); PreparedStatement ps = con.prepareStatement(sqlString.toString());) {
+			Iterator<Integer> it = parameterMap.keySet().iterator();
+			while (it.hasNext()) {
+				Integer key = it.next();
+				Object data = parameterMap.get(key);
+				ps.setObject(key, data);
+			}
+
+			try (ResultSet resultSet = ps.executeQuery()) {
+				int columnCount = resultSet.getMetaData().getColumnCount();
+				List<String> headLines = new ArrayList<String>(columnCount);
+				for (int i = 1; i <= columnCount; i++) {
+					headLines.add(resultSet.getMetaData().getColumnLabel(i));
+				}
+				HashMap<String, Object> currentItem;
+				while (resultSet.next()) {
+					currentItem = new HashMap<String, Object>();
+					for (String headline : headLines) {
+						int index = headLines.indexOf(headline) + 1;
+						currentItem.put(headline, resultSet.getObject(index));
+						
+					}
+					result.add(currentItem);
+				}
+		}
+		catch (SQLException e) {
+			throw e;
+		}
+		}
+		return result;
+	}
+
+//	public List<HashMap<String, Object>> jdbcSelectAsMap(CharSequence sqlString) {
+//		List<HashMap<String, Object>> result = new ArrayList<HashMap<String, Object>>();
+//		try {
+//			result = jdbcSelectAsMapWithFeedback(sqlString);
+//		}
+//		catch (Exception e) {
+//			e.printStackTrace();
+//		}
+//		return result;
+//	}
+
+	
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlString
+	 *                    Select you want to execute
+	 * @param columnCount
+	 *                    Number of columns of the given SQL
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 * @throws SQLException
+	 */
+//	public List<GeisJdbcArray> jdbcSelectWithSizeWithFeedbackExtended(CharSequence sqlString, int columnCount) throws SQLException {
+//		List<GeisJdbcArray> result = new ArrayList<>();
+//		try (Connection con = getConnection(); Statement stmt = con.createStatement(); ResultSet res = stmt.executeQuery(sqlString.toString())) {
+//			while (res.next()) {
+//				Object[] array = new Object[columnCount];
+//				for (int i = 1; i <= columnCount; i++) {
+//					if (res.getObject(i) instanceof AS400JDBCClobLocator) {
+//						array[i - 1] = IOUtils.toString(res.getClob(i).getCharacterStream());
+//					} else {
+//						array[i - 1] = res.getObject(i);
+//					}
+//				}
+//				result.add(new GeisJdbcArray(array));
+//			}
+//		}
+//		catch (SQLException e) {
+//			// Malformed SQL
+//			throw e;
+//		} catch (IOException e) {
+//			e.printStackTrace();
+//		}
+//		return result;
+//	}
+//
+//	public List<GeisJdbcArray> jdbcSelectWithSizeExtended(CharSequence sqlString, int columnCount) {
+//		List<GeisJdbcArray> result = new ArrayList<>();
+//		try {
+//			result = jdbcSelectWithSizeWithFeedbackExtended(sqlString, columnCount);
+//		}
+//		catch (Exception e) {
+//			e.printStackTrace();
+//		}
+//		return result;
+//	}
+
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlString
+	 *                    Select you want to execute
+	 * @param columnCount
+	 *                    Number of columns of the given SQL
+	 * @param maxRows
+	 *                    Select First x Rows only
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 */
+//	public List<Object[]> jdbcSelectWithSize(String sqlString, int columnCount, int maxRows) {
+//		return jdbcSelectWithSize(new StringBuilder(sqlString).append(" FETCH FIRST ").append(maxRows).append(" ROWS ONLY").toString(), columnCount);
+//	}
+
+	/**
+	 * Should suffice for any Insert/Update/Delete you want to execute. Returns an
+	 * List of Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 *
+	 * @param sqlString
+	 *                  Insert/Update/Delete you want to execute
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 */
+	public int jdbcUpdateWithFeedback(CharSequence sqlString) throws SQLException {
+		try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
+			con.setAutoCommit(false);
+			int result = stmt.executeUpdate(sqlString.toString());
+			con.commit();
+			return result;
+		}
+		catch (SQLException e) {
+			// Malformed SQL
+			throw e;
+		}
+	}
+
+	public int jdbcInsert(CharSequence sqlString) throws SQLException {
+		try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
+			con.setAutoCommit(false);
+			int result = stmt.executeUpdate(sqlString.toString());
+			con.commit();
+			return result;
+		}
+		catch (SQLException e) {
+			throw e;
+		}
+	}
+
+	public int jdbcUpdate(CharSequence sqlString) {
+		try {
+			return jdbcUpdateWithFeedback(sqlString.toString());
+		}
+		catch (Exception e) {
+			Exceptions.prettyPrintGeisException(e, true);
+		}
+		return 0;
+	}
+
+	public boolean jdbcUnsaveInsertOrDelete(CharSequence sqlString) {
+		try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
+			con.setAutoCommit(false);
+			boolean result = stmt.execute(sqlString.toString());
+			con.commit();
+			return result;
+		}
+		catch (SQLException e) {}
+		return false;
+	}
+
+	/**
+	 * Should suffice for any Insert/Update/Delete you want to execute transaction
+	 * safe. Returns an List of Objectarrays, whereas a each ObjectArray is a Line
+	 * in the Database.
+	 *
+	 * @param sqlString
+	 *                  Insert/Update/Delete you want to execute
+	 * @return True = worked, False = error occured
+	 */
+	public boolean jdbcUpdateTransactionSave(List<String> sqlList) {
+		try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
+			con.setAutoCommit(false);
+			for (String sqlString : sqlList) {
+				stmt.executeUpdate(sqlString);
+			}
+			con.commit();
+		}
+		catch (SQLException e) {
+			// Malformed SQL
+			e.printStackTrace();
+			return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Should suffice for any Insert/Update/Delete you want to execute in
+	 * transaction.
+	 *
+	 * @param sqlList
+	 *                Insert/Update/Delete collection you want to execute
+	 * @throws SQLException
+	 */
+	public void jdbcUpdateInTransactionWithFeedback(List<String> sqlList) throws SQLException {
+		try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
+			try {
+				con.setAutoCommit(false);
+				for (String sqlString : sqlList) {
+					stmt.executeUpdate(sqlString);
+				}
+				con.commit();
+			}
+			catch (Exception e) {
+				con.rollback();
+				throw e;
+			}
+			finally {
+				con.setAutoCommit(true);
+			}
+		}
+		catch (SQLException e) {
+			throw e;
+		}
+	}
+	
+	
+	/**
+	 * Should suffice for any Select you want to execute. Returns an List of
+	 * Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 * 
+	 * @param sqlBuffer
+	 *            Select you want to execute
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 */
+	public boolean jdbcDelete(CharSequence sqlString) {
+		boolean result = true;
+		try {
+			result = jdbcDeleteWithFeedback(sqlString.toString());
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return result;
+	}
+	
+	/**
+	 * Should suffice for any Insert/Update/Delete you want to execute. Returns an
+	 * List of Objectarrays, whereas a each ObjectArray is a Line in the Database.
+	 * 
+	 * @param sqlString
+	 *            Insert/Update/Delete you want to execute
+	 * @return List of ObjectArray. Every ObjectArray is a item of the table. Array
+	 *         is sorted along the given SQL
+	 */
+	public boolean jdbcDeleteWithFeedback(CharSequence sqlString) throws SQLException {
+		try (Connection con = getConnection(); Statement stmt = con.createStatement()) {
+			con.setAutoCommit(false);
+			boolean result = stmt.execute(sqlString.toString());
+			con.commit();
+			return result;
+		} catch (SQLException e) {
+			throw e;
+		}
+	}
+
+	/**
+	 * Function to retrieve Connection from Do not use this unless necessary, use
+	 * implemented Methods
+	 *
+	 * @return Conection from Pool
+	 */
+	@Deprecated
+	public Connection getConnection() {
+		try {
+			Connection con = ((DataSource) new InitialContext().lookup(DBTools.getJNDIConnectionString(SCHEMA))).getConnection();
+			if (!SCHEMA.equals(SchemataENUM.GTMS) && !SCHEMA.equals(SchemataENUM.GTMS5)) {
+				con.setSchema(SCHEMA.name());
+			}
+			return con;
+		}
+		catch (SQLException e) {
+			// Malformed SQL
+			e.printStackTrace();
+		}
+		catch (NamingException e) {
+			// Should not happen. Lookup faild, usually impossible.
+			e.printStackTrace();
+		}
+		return null;
+	}
+
+	/**
+	 * Function to call a Remote FKT
+	 *
+	 * @param lib
+	 *                  Library you want to use
+	 * @param pgmname
+	 *                  Name of the program to call
+	 * @param parameter
+	 *                  Parameter combination
+	 * @return Returnparameter of the called programm
+	 */
+//	public String callRemoteFKT(String lib, String pgmname, String parameter) {
+//		try (Connection con = getConnection(); CallableStatement cs = con.prepareCall("{call GEISPGM.REMOTEFKT(?,?,?,?)}");) {
+//			cs.setString(1, pgmname);
+//			cs.setString(2, lib);
+//			cs.setString(3, StringUtil.fillString(parameter, 500, " ", false));
+//			cs.registerOutParameter(4, Types.VARCHAR);
+//			cs.executeUpdate();
+//			return cs.getString(4);
+//		}
+//		catch (SQLException e) {
+//			// Fehler bei den Übergabeparameter
+//			e.printStackTrace();
+//			return null;
+//		}
+//	}
+
+	// ------------------------------ HIBERNATE ------------------------------
+
+	/**
+	 * enables debug system.out.prints
+	 */
+	private final Boolean DEBUG;
+
+	//Log4j2Handler log4j2Handler = null;
+
+	/**
+	 * enables logging
+	 */
+	private final boolean LOG;
+
+	/**
+	 * Function to retrieve Connection from
+	 *
+	 * @return Connection from Pool
+	 */
+	public Session getSession() {
+		try {
+			return sessionFactory.openSession();
+		}
+		catch (Throwable e) {
+			Exceptions.prettyPrintGeisException(e, true);
+			return null;
+		}
+	}
+
+	/**
+	 * Represents "Select * from 'database'.'table'"
+	 *
+	 * @param table
+	 *                table to select from
+	 * @return all sets in chosen table
+	 */
+	@SuppressWarnings("unchecked")
+	public <E> List<E> loadAll(final Class<E> table) {
+		return (List<E>) loadAll(table.getSimpleName(), 0);
+	}
+
+	/**
+	 * Represents "Select * from 'database'.'table'"
+	 *
+	 * @param tabelle
+	 *                table to select from
+	 * @return all sets in chosen table
+	 */
+	public List<?> loadAll(String tabelle) {
+		return loadAll(tabelle, 0);
+	}
+
+	/**
+	 * Represents "Select * from 'database'.'table'"
+	 *
+	 * @param tabelle
+	 *                  table to select from
+	 * @param maxResult
+	 *                  0 not used >0 get max Result
+	 * @return all sets in chosen table
+	 */
+	@SuppressWarnings({ "rawtypes" })
+	public List<?> loadAll(String tabelle, int maxResult) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+
+			Query q = ses.createQuery("FROM " + tabelle);
+
+			if (maxResult > 0) {
+				q.setFetchSize(maxResult).setMaxResults(maxResult).setFirstResult(0);
+			}
+
+			if (DEBUG) {
+				System.out.println(q.getQueryString());
+			}
+
+			return q.list();
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+	
+	/**
+	 * Represents "Select * from 'database'.'table'" <-- Trimmed
+	 *
+	 * @param table
+	 *                table to select from
+	 * @return all sets in chosen table with TRIM
+	 */
+	@SuppressWarnings("unchecked")
+	public <E> List<E> loadAllWithTrim(final Class<E> table) {
+		return (List<E>) loadAllWithTrim(table.getSimpleName(), 0);
+	}
+
+	/**
+	 * Represents "Select * from 'database'.'table'" <-- Trimmed
+	 *
+	 * @param tabelle
+	 *                table to select from
+	 * @return all sets in chosen table with TRIM
+	 */
+	public List<?> loadAllWithTrim(String tabelle) {
+		return loadAllWithTrim(tabelle, 0);
+	}
+	
+	/**
+	 * Represents "Select * from 'database'.'table'" <-- Trimmed
+	 *
+	 * @param tabelle
+	 *                  table to select from
+	 * @param maxResult
+	 *                  0 not used >0 get max Result
+	 * @return all sets in chosen table with TRIM
+	 */
+	@SuppressWarnings({ "rawtypes" })
+	public List<?> loadAllWithTrim(String tabelle, int maxResult) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+
+			Query q = ses.createQuery("FROM " + tabelle);
+
+			if (maxResult > 0) {
+				q.setFetchSize(maxResult).setMaxResults(maxResult).setFirstResult(0);
+			}
+
+			if (DEBUG) {
+				System.out.println(q.getQueryString());
+			}
+			
+			return MyObject.trimReflectiveString(q.list());
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+	
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause' fetch first
+	 * row only"
+	 *
+	 * @param tabelle
+	 *                tabelle table to select from
+	 * @param where
+	 *                whereclause, empty for no where clause. Use
+	 *                ToolsSQL.buildWhereHQL for this
+	 * @return first set in chosen table in where context
+	 */
+	@SuppressWarnings("unchecked")
+	public <E> E loadByWhereFirstObject(final Class<E> table, final CharSequence where) {
+		return (E) loadByWhereFirstObject(table.getSimpleName(), where == null ? "" : where.toString());
+	}
+
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause' fetch first
+	 * row only"
+	 *
+	 * @param tabelle
+	 *                tabelle table to select from
+	 * @param where
+	 *                whereclause, empty for no where clause. Use
+	 *                ToolsSQL.buildWhereHQL for this
+	 * @return first set in chosen table in where context
+	 */
+	@SuppressWarnings({ "rawtypes" })
+	public Object loadByWhereFirstObject(String tabelle, CharSequence where) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			// System.out.println("beginTransaction" + tx.isActive());
+
+			StringBuilder stringBuilder = new StringBuilder("FROM ");
+			stringBuilder.append(tabelle);
+			if (!StringUtil.safeTrimObjWithReplace(where).isEmpty()) {
+				stringBuilder.append(" where ");
+				stringBuilder.append(where);
+			}
+			Query q = ses.createQuery(stringBuilder.toString()).setFetchSize(1).setMaxResults(1).setFirstResult(0);
+			if (DEBUG) {
+				System.out.println(q.getQueryString());
+			}
+			List<?> objectList = q.list();
+			if (objectList != null && !objectList.isEmpty()) { return objectList.get(0); }
+			return null;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+	
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause' fetch first <-- Trimmed
+	 * row only"
+	 *
+	 * @param tabelle
+	 *                tabelle table to select from
+	 * @param where
+	 *                whereclause, empty for no where clause. Use
+	 *                ToolsSQL.buildWhereHQL for this
+	 * @return first set in chosen table in where context with TRIM
+	 */
+	@SuppressWarnings("unchecked")
+	public <E> E loadByWhereFirstObjectWithTrim(final Class<E> table, final CharSequence where) {
+		return (E) loadByWhereFirstObjectWithTrim(table.getSimpleName(), where == null ? "" : where.toString());
+	}
+	
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause' fetch first
+	 * row only" <-- Trimmed
+	 *
+	 * @param tabelle
+	 *                tabelle table to select from
+	 * @param where
+	 *                whereclause, empty for no where clause. Use
+	 *                ToolsSQL.buildWhereHQL for this
+	 * @return first set in chosen table in where context with TRIM
+	 */
+	@SuppressWarnings({ "rawtypes" })
+	public Object loadByWhereFirstObjectWithTrim(String tabelle, CharSequence where) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			// System.out.println("beginTransaction" + tx.isActive());
+
+			StringBuilder stringBuilder = new StringBuilder("FROM ");
+			stringBuilder.append(tabelle);
+			if (!StringUtil.safeTrimObjWithReplace(where).isEmpty()) {
+				stringBuilder.append(" where ");
+				stringBuilder.append(where);
+			}
+			Query q = ses.createQuery(stringBuilder.toString()).setFetchSize(1).setMaxResults(1).setFirstResult(0);
+			if (DEBUG) {
+				System.out.println(q.getQueryString());
+			}
+			List<?> objectList = q.list();
+			if (objectList != null && !objectList.isEmpty()) { return MyObject.trimReflectiveString(objectList.get(0)); }
+			return null;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause'"
+	 *
+	 * @param tabelle
+	 *                tabelle table to select from
+	 * @param where
+	 *                whereclause, empty for no where clause ( Please take loadAll
+	 *                instead if possible) Use ToolsSQL.buildWhereHQL for this
+	 * @return all set in chosen table in where context
+	 */
+	public List<?> loadByWhereList(String tabelle, CharSequence where) {
+		return loadByWhereList(tabelle, where == null ? "" : where.toString(), 0);
+	}
+
+	/**
+	 * Represents "Select * from 'database'.'table' where 'where'"
+	 * @param <E> - 
+	 * @param table - Table
+	 * @param where - WHERE - Condition
+	 * @return List of type objects, not a generic list
+	 */
+	@SuppressWarnings("unchecked")
+	public <E> List<E> loadByWhereList(final Class<E> table, final CharSequence where) {
+		return (List<E>) loadByWhereList(table.getSimpleName(), where == null ? "" : where.toString(), 0);
+	}
+	
+	/**
+	 * 
+	 * @param <E>
+	 * @param table tabelle table to select from
+	 * @param where  whereclause, empty for no where clause ( Please take loadAll instead if possible) Use ToolsSQL.buildWhereHQL for this
+	 * @param maxResult 0 not used >0 get max Result
+	 * @return
+	 */
+	@SuppressWarnings("unchecked")
+	public <E> List<E> loadByWhereList(final Class<E> table, final CharSequence where, final int maxResult) {
+		return (List<E>) loadByWhereList(table.getSimpleName(), where == null ? "" : where.toString(), maxResult);
+	}
+	
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause'"
+	 *
+	 * @param tabelle
+	 *                  tabelle table to select from
+	 * @param where
+	 *                  whereclause, empty for no where clause ( Please take loadAll
+	 *                  instead if possible) Use ToolsSQL.buildWhereHQL for this
+	 * @param maxResult
+	 *                  0 not used >0 get max Result
+	 * @return	all set in chosen table in where context
+	 */
+	@SuppressWarnings({ "rawtypes" })
+	public List<?> loadByWhereList(String tabelle, CharSequence where, int maxResult) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			// System.out.println("beginTransaction" + tx.isActive());
+
+			StringBuilder stringBuilder = new StringBuilder("FROM ");
+			stringBuilder.append(tabelle);
+			if (!StringUtil.safeTrimObjWithReplace(where).isEmpty()) {
+				stringBuilder.append(" WHERE ");
+				stringBuilder.append(where);
+			}
+			Query q = ses.createQuery(stringBuilder.toString());
+
+			if (maxResult > 0) {
+				q.setFetchSize(maxResult).setMaxResults(maxResult).setFirstResult(0);
+			}
+
+			if (DEBUG) {
+				System.out.println(q.getQueryString());
+			}
+			return q.list();
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+	
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause'" <-- Trimmed
+	 *
+	 * @param tabelle
+	 *                tabelle table to select from
+	 * @param where
+	 *                whereclause, empty for no where clause ( Please take loadAll
+	 *                instead if possible) Use ToolsSQL.buildWhereHQL for this
+	 * @return all set in chosen table in where context with TRIM
+	 */
+	public List<?> loadByWhereListWithTrim(String tabelle, CharSequence where) {
+		return loadByWhereListWithTrim(tabelle, where == null ? "" : where.toString(), 0);
+	}
+
+	/**
+	 * Represents "Select * from 'database'.'table' where 'where'" <-- Trimmed
+	 * @param <E> - 
+	 * @param table - Table
+	 * @param where - WHERE - Condition
+	 * @return List of type objects, not a generic list with TRIM
+	 */
+	@SuppressWarnings("unchecked")
+	public <E> List<E> loadByWhereListWithTrim(final Class<E> table, final CharSequence where) {
+		return (List<E>) loadByWhereListWithTrim(table.getSimpleName(), where == null ? "" : where.toString(), 0);
+	}
+	
+	/**
+	 * 
+	 * @param <E>
+	 * @param table tabelle table to select from <-- Trimmed
+	 * @param where  whereclause, empty for no where clause ( Please take loadAll instead if possible) Use ToolsSQL.buildWhereHQL for this
+	 * @param maxResult 0 not used >0 get max Result with TRIM
+	 * @return
+	 */
+	@SuppressWarnings("unchecked")
+	public <E> List<E> loadByWhereListWithTrim(final Class<E> table, final CharSequence where, final int maxResult) {
+		return (List<E>) loadByWhereListWithTrim(table.getSimpleName(), where == null ? "" : where.toString(), maxResult);
+	}
+	
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause'" <-- Trimmed
+	 *
+	 * @param tabelle
+	 *                  tabelle table to select from
+	 * @param where
+	 *                  whereclause, empty for no where clause ( Please take loadAll
+	 *                  instead if possible) Use ToolsSQL.buildWhereHQL for this
+	 * @param maxResult
+	 *                  0 not used >0 get max Result
+	 * @return all set in chosen table in where context with TRIM
+	 */
+	@SuppressWarnings({ "rawtypes", "resource", "unchecked" })
+	public List<?> loadByWhereListWithTrim(String tabelle, CharSequence where, int maxResult) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			// System.out.println("beginTransaction" + tx.isActive());
+
+			StringBuilder stringBuilder = new StringBuilder("FROM ");
+			stringBuilder.append(tabelle);
+			if (!StringUtil.safeTrimObjWithReplace(where).isEmpty()) {
+				stringBuilder.append(" WHERE ");
+				stringBuilder.append(where);
+			}
+			System.out.println(stringBuilder.toString());
+			Query q = ses.createQuery(stringBuilder.toString());
+
+			if (maxResult > 0) {
+				q.setFetchSize(maxResult).setMaxResults(maxResult).setFirstResult(0);
+			}
+
+			if (DEBUG) {
+				System.out.println(q.getQueryString());
+			}
+			return MyObject.trimReflectiveListString(q.list());
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+
+
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause'"
+	 *
+	 * @param sql
+	 * @return all set in chosen table in where context
+	 */
+	public List<?> loadBySqlList(CharSequence sql) {
+		return loadBySqlList(sql, 0);
+	}
+
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause'"
+	 *
+	 * @param sql
+	 * @param maxResult
+	 *                  0 not used >0 get max Result
+	 * @return all set in chosen table in where context
+	 */
+	@SuppressWarnings({ "rawtypes" })
+	public List<?> loadBySqlList(CharSequence sql, int maxResult) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+
+			// System.out.println("beginTransaction" + tx.isActive());
+			Query q = ses.createQuery(sql.toString());
+
+			if (maxResult > 0) {
+				q.setFetchSize(maxResult).setMaxResults(maxResult).setFirstResult(0);
+			}
+
+			if (DEBUG) {
+				System.out.println(q.getQueryString());
+			}
+			return q.list();
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+	
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause'" <-- Trimmed
+	 *
+	 * @param sql
+	 * @return all set in chosen table in where context with TRIM
+	 */
+	public List<?> loadBySqlListWithTrim(CharSequence sql) {
+		return loadBySqlListWithTrim(sql, 0);
+	}
+	
+	/**
+	 * Represents "Select * from 'database'.'table' where 'whereclause'" <-- Trimmed
+	 *
+	 * @param sql
+	 * @param maxResult
+	 *                  0 not used >0 get max Result
+	 * @return all set in chosen table in where context with TRIM
+	 */
+	@SuppressWarnings({ "rawtypes" })
+	public List<?> loadBySqlListWithTrim(CharSequence sql, int maxResult) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+
+			// System.out.println("beginTransaction" + tx.isActive());
+			Query q = ses.createQuery(sql.toString());
+
+			if (maxResult > 0) {
+				q.setFetchSize(maxResult).setMaxResults(maxResult).setFirstResult(0);
+			}
+
+			if (DEBUG) {
+				System.out.println(q.getQueryString());
+			}
+			return MyObject.trimReflectiveListString(q.list());
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+
+	/**
+	 * Represents "Insert" Statement
+	 *
+	 * @param object
+	 *               single set to be inserted to its table
+	 */
+	public boolean insertObject(Object object) {
+		if (object == null) {
+			System.out.println("Die übergebene Object war fehlerhaft");
+			return false;
+		}
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			ses.save(object);
+			tx.commit();
+			if (DEBUG) {
+				System.out.println("Es wird ein " + object.getClass().getCanonicalName() + " gespeichert");
+			}
+			return true;
+		}
+		catch (PersistenceException e) {
+			System.out.println(DBTools.validateHibernateObject(object));
+			return false;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return false;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+
+	/**
+	 * Represents "Insert" Statement
+	 *
+	 * @param object
+	 *               single set to be inserted to its table
+	 */
+	public Object insertObjectReturningID(Object object) {
+		if (object == null) {
+			System.out.println("Die übergebene Object war fehlerhaft");
+			return null;
+		}
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			Object newID = ses.save(object);
+			tx.commit();
+			if (DEBUG) {
+				System.out.println("Es wird ein " + object.getClass().getCanonicalName() + " gespeichert");
+			}
+			return newID;
+		}
+		catch (PersistenceException e) {
+			System.out.println(DBTools.validateHibernateObject(object));
+			return null;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+
+	
+	/**
+	 * Represents "Insert" Statement in a for-each loop
+	 *
+	 * @param list
+	 *             List of sets to be inserted to its table
+	 */
+	public boolean insertList(List<?> list) {
+		if (list == null || list.isEmpty()) {
+			System.out.println("Die übergebene Liste war fehlerhaft");
+			return false;
+		}
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			for (Object object : list) {
+				ses.save(object.getClass().cast(object));
+			}
+			tx.commit();
+			if (DEBUG) {
+				System.out.println("Die Liste wurde gespeichert");
+			}
+			return true;
+		}
+		catch (PersistenceException e) {
+			System.out.println("Persistance fehler");
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return false;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return false;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+}
+
+	/**
+	 * Represents "Insert" Statement in a for-each loop
+	 *
+	 * @param list
+	 *             List of sets to be inserted to its table
+	 */
+	public List<Object> insertListReturningID(List<?> list) {
+		List<Object> newIDs = new ArrayList<Object>();
+		if (list == null || list.isEmpty()) {
+			System.out.println("Die übergebene Liste war fehlerhaft");
+			return newIDs;
+		}
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			for (Object object : list) {
+				newIDs.add(ses.save(object.getClass().cast(object)));
+			}
+			tx.commit();
+			if (DEBUG) {
+				System.out.println("Die Liste wurde gespeichert");
+			}
+		}
+		catch (PersistenceException e) {
+			System.out.println(DBTools.validateHibernateObject(list));
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+		return newIDs;
+}
+
+	/**
+	 * Represents "Update" Statement
+	 *
+	 * @param object
+	 *               single set to be updated to its table
+	 * @return boolean Status
+	 *
+	 */
+	public boolean updateObject(Object object) {
+		Session ses = null;
+		Transaction tx = null;
+		
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+//			ses.setProperty("CHGUSER", "TESTUSER");
+			ses.update(object);
+			tx.commit();
+			if (DEBUG) {
+				System.out.println("Es wird ein " + object.getClass().getCanonicalName() + " geupdatet");
+			}
+			return true;
+		}
+		catch (PersistenceException e) {
+			System.out.println(DBTools.validateHibernateObject(object));
+			return false;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return false;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+
+	/**
+	 * Represents "Update" Statement in a for-each loop
+	 *
+	 * @param object
+	 *               List of sets to be updated to its table
+	 */
+	public boolean updateList(List<?> list) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			for (Object object : list) {
+				ses.update(object.getClass().cast(object));
+			}
+			tx.commit();
+			if (DEBUG) {
+				System.out.println("Die Liste wurde geupdatet");
+			}
+			return true;
+		}
+		catch (PersistenceException e) {
+			System.out.println(DBTools.validateHibernateObject(list));
+			return false;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return false;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+}
+
+	/**
+	 * Represents "Delete" Statement
+	 *
+	 * @param object
+	 *               single set to be deleted to its table
+	 */
+	public boolean deleteObject(Object object) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			ses.delete(object.getClass().cast(object));
+			tx.commit();
+			if (DEBUG) {
+				System.out.println("Es wird ein " + object.getClass().getCanonicalName() + " gelöscht");
+			}
+			return true;
+		}
+		catch (PersistenceException e) {
+			System.out.println(DBTools.validateHibernateObject(object));
+			return false;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return false;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+
+	/**
+	 * Represents "Delete" Statement in a for-each loop
+	 *
+	 * @param object
+	 *               List of sets to be deleted to its table
+	 */
+	public boolean deleteList(List<?> list) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			for (Object object : list) {
+				ses.delete(object.getClass().cast(object));
+			}
+			tx.commit();
+			if (DEBUG) {
+				System.out.println("Die Liste wurde gelöscht");
+			}
+			return true;
+		}
+		catch (PersistenceException e) {
+			System.out.println(DBTools.validateHibernateObject(list));
+			return false;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return false;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+
+	/**
+	 * Function to do an transaction safe Insert Update and Delete at a time. Not
+	 * every List have to be filled.
+	 *
+	 * @param insertList
+	 *                   List to be inserted
+	 * @param updateList
+	 *                   List to be updated
+	 * @param deleteList
+	 *                   List to be deleted
+	 */
+	public boolean transactionSafeDBFunctions(List<?> insertList, List<?> updateList, List<?> deleteList) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+			if (insertList != null) {
+				for (Object object : insertList) {
+					ses.save(object.getClass().cast(object));
+				}
+			}
+			if (updateList != null) {
+				for (Object object : updateList) {
+					ses.update(object.getClass().cast(object));
+				}
+			}
+			if (deleteList != null) {
+				for (Object object : deleteList) {
+					ses.delete(object.getClass().cast(object));
+				}
+			}
+			tx.commit();
+			if (DEBUG) {
+				System.out.println("Die InsertList wurde gespeichert, die UpdateList wurde geupdatet, die DeleteList wurde gelöscht");
+			}
+			return true;
+		}
+		catch (PersistenceException e) {
+			System.out.println(DBTools.validateHibernateObject(insertList));
+			System.out.println(DBTools.validateHibernateObject(updateList));
+			System.out.println(DBTools.validateHibernateObject(deleteList));
+			return false;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return false;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+}
+
+	/**
+	 * Function to do safe Insert Update at a time. Not every List have to be
+	 * filled.
+	 *
+	 * @param insertUpdateList
+	 *                         List to be inserted or update
+	 */
+	public boolean instertOrUpdateList(List<?> insertUpdateList) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+
+			for (Object object : insertUpdateList) {
+				ses.saveOrUpdate(object.getClass().cast(object));
+			}
+			tx.commit();
+			if (DEBUG) {
+				System.out.println("Die InsertList wurde gespeichert, die UpdateList wurde geupdatet, die DeleteList wurde gelöscht");
+			}
+			return true;
+		}
+		catch (Exception e) {
+			e.printStackTrace();
+			if (LOG) {
+				//log4j2Handler.setUsername("System");
+				//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			}
+			return false;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+}
+
+	public List<Object[]> getObjectArrayListFromSqlJoin(CharSequence sql) {
+		return getObjectArrayListFromSqlJoin(sql, 0);
+	}
+
+	@SuppressWarnings({ "unchecked" })
+	public List<Object[]> getObjectArrayListFromSqlJoin(CharSequence sql, int maxResult) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+
+			if (DEBUG) {
+				System.out.println("Transaction Aktive: " + tx.isActive());
+				System.out.println(sql.toString());
+			}
+			Query<Object[]> q = ses.createQuery(sql.toString()).setReadOnly(true);
+			if (maxResult != 0) {
+				q.setFetchSize(maxResult).setMaxResults(maxResult).setFirstResult(0);
+			}
+			return q.list();
+		}
+		catch (Exception e) {
+			//log4j2Handler.setUsername("System");
+			//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+	
+	public List<Object[]> getObjectArrayListFromSqlJoinWithTrim(CharSequence sql) {
+		return getObjectArrayListFromSqlJoinWithTrim(sql, 0);
+	}
+	
+	@SuppressWarnings({ "unchecked" })
+	public List<Object[]> getObjectArrayListFromSqlJoinWithTrim(CharSequence sql, int maxResult) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			ses = getSession();
+			tx = ses.beginTransaction();
+
+			if (DEBUG) {
+				System.out.println("Transaction Aktive: " + tx.isActive());
+				System.out.println(sql.toString());
+			}
+			Query<Object[]> q = ses.createQuery(sql.toString()).setReadOnly(true);
+			if (maxResult != 0) {
+				q.setFetchSize(maxResult).setMaxResults(maxResult).setFirstResult(0);
+			}
+			return MyObject.trimReflectiveObjectListString(q.list());
+		}
+		catch (Exception e) {
+			//log4j2Handler.setUsername("System");
+			//log4j2Handler.log(Level.ERROR, Log4j2Source.DATABASE, e.getMessage(), e, null);
+			return null;
+		}
+		finally {
+			safeClose(tx, ses);
+		}
+	}
+	
+	/**
+	 * TEST-METHOD ONLY
+	 * @param sql
+	 * @param classes
+	 * @return
+	 */
+	@SuppressWarnings({ "deprecation", "unchecked" })
+	public List<Object[]> loadJOIN(final CharSequence sql, final Class<?> ... classes) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			
+			ses = getSession();
+			
+			tx = ses.beginTransaction();
+			
+			NativeQuery<Object[]> q = ses.createNativeQuery(sql.toString());
+			
+			for (final Class<?> c : classes) {
+				q = q.addEntity(c);
+			}
+				
+			return q.list();
+		} catch (final Exception e) {
+			e.printStackTrace();
+		} finally {
+			safeClose(tx, ses);
+		}
+		
+		return Collections.EMPTY_LIST;
+	}
+	
+	@SuppressWarnings({ "deprecation", "unchecked" })
+	public List<Object[]> loadJOINWithTrim(final CharSequence sql, final Class<?> ... classes) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			
+			ses = getSession();
+			
+			tx = ses.beginTransaction();
+			
+			NativeQuery<Object[]> q = ses.createNativeQuery(sql.toString());
+			
+			for (final Class<?> c : classes) {
+				q = q.addEntity(c);
+			}
+				
+			return MyObject.trimReflectiveObject(q.list());
+		} catch (final Exception e) {
+			e.printStackTrace();
+		} finally {
+			safeClose(tx, ses);
+		}
+		
+		return Collections.EMPTY_LIST;
+	}
+
+	@SuppressWarnings("resource")
+	public <T> List<T> loadNative(final CharSequence sql, final Class<T> clazz) {
+		Session ses = null;
+		Transaction tx = null;
+		try {
+			
+			ses = getSession();
+			
+			tx = ses.beginTransaction();
+			
+			NativeQuery<T> q = ses.createNativeQuery(sql.toString(), clazz);
+				
+			return q.list();
+		} catch (final Exception e) {
+			e.printStackTrace();
+		} finally {
+			safeClose(tx, ses);
+		}
+		
+		return Collections.emptyList();
+	}
+	
+	private static void safeClose(Transaction tx, Session ses) {
+		try {
+			if (tx != null && tx.isActive()) {
+				tx.rollback();
+			}
+		}
+		catch (Exception ignoredException) {}
+		try {
+			if (ses != null) {
+				ses.close();
+			}
+		}
+		catch (Exception ignoredException) {}
+	}
+
+	// ------------------------------ Globale ------------------------------
+
+	/**
+	 * SCHEMA. e.g. GEISDTT
+	 */
+	private final SchemataENUM SCHEMA;
+
+	/**
+	 * Constructor of a HibernateWorker
+	 *
+	 * @param datenbank
+	 *                  string container for database. e.g. GEISDTT
+	 * @param debug
+	 *                  enables debug system.out.prints
+	 * @param log
+	 *                  enables logging
+	 */
+	public DBHandler(SchemataENUM schema, boolean debug, boolean log) {
+		SCHEMA = schema;
+		DEBUG = debug;
+		LOG = log;
+		//log4j2Handler = new Log4j2Handler(this);
+		sessionFactory = SESSIONPOOLMAP.get(SCHEMA);
+	}
+
+	/**
+	 * Constructor of a HibernateWorker
+	 *
+	 * @param datenbank
+	 *                  string container for database. e.g. GEISDTT
+	 * @param debug
+	 *                  enables debug system.out.prints
+	 * @param log
+	 *                  disabled logging
+	 */
+	public DBHandler(SchemataENUM schema, boolean debug) {
+		this(schema, debug, false);
+	}
+
+	/**
+	 * Constructor of a Worker
+	 *
+	 * @param datenbank
+	 *                  string container for database. e.g. GEISDTT
+	 * @param debug
+	 *                  disabled debug system.out.prints
+	 * @param log
+	 *                  disabled logging
+	 */
+	public DBHandler(SchemataENUM schema) {
+		this(schema, false, false);
+	}
+
+}
diff --git a/src/main/java/de/tvo/files/CreateFile.java b/src/main/java/de/tvo/files/CreateFile.java
new file mode 100644
index 0000000..a87c74a
--- /dev/null
+++ b/src/main/java/de/tvo/files/CreateFile.java
@@ -0,0 +1,114 @@
+package de.tvo.files;
+
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.imageio.ImageIO;
+
+import de.tvo.images.ImageScale;
+
+public class CreateFile {
+
+	public CreateFile() {
+		// TODO Auto-generated constructor stub
+	}
+
+	public static void main(String[] args) {
+
+		File file = new File("C:\\Transfer\\Bilder\\bild.jpg");
+		
+		System.out.println("File exist: " + file.isFile());
+		byte[] buffer = new byte[(int) file.length()];
+	    InputStream ios = null;
+		try {
+
+
+		    try {
+		        ios = new FileInputStream(file);
+		        if (ios.read(buffer) == -1) {
+		            throw new IOException(
+		                    "EOF reached while trying to read the whole file");
+		        }
+		    } finally {
+		        try {
+		            if (ios != null)
+		                ios.close();
+		        } catch (IOException e) {
+		        }
+		    }
+			
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	    createPictureFile("C:\\Transfer\\Bilder\\", "bildneu.jpg", buffer);
+
+	}
+	
+	public static boolean createPictureFile(String folder, String filename, byte[] pictureData) {
+		boolean status = true;
+		
+		try {
+			BufferedImage bufferedImage = ImageScale.convertBufferdImageFromByteArray(pictureData);
+			File outputfile = new File(folder + filename);
+			ImageIO.write(bufferedImage, "jpg", outputfile);
+		} catch (Exception e) {
+			e.printStackTrace();
+			status = false;
+		} finally {
+			
+		}
+		
+		
+		return status;
+	}
+	
+	/**
+	 * Creating a File
+	 * @param fileName filename (inc. path) to be written to
+	 * @param fileData Content of file to be written
+	 * @param append true : adds content at end. False : adds content at start
+	 * @param debug true : Some Console output. False : No console output
+	 * @return true : Data written. false : Data could not be written
+	 */
+	public static boolean createFile(String fileName, String fileData, boolean append, boolean debug) {
+		if (debug){
+			System.out.println(fileName);
+			System.out.println(fileData);
+		}
+		try {
+			FileWriter f1 = new FileWriter(fileName, append);
+			f1.write(fileData);
+			f1.close();
+			return true;
+		} catch (IOException e) {
+			System.out.println("Fehler beim Erstellen der Datei");
+		} finally {
+			
+		}
+		return false;
+	}
+
+	/**
+	 * Creating a File. No Debug
+	 * @param fileName filename (inc. path) to be written to
+	 * @param fileData Content of file to be written
+	 * @param append true : adds content at end. False : adds content at start
+	 * @return true : Data written. false : Data could not be written
+	 */
+	public static boolean createFile(String fileName, String fileData, boolean append) {
+		try {
+			FileWriter f1 = new FileWriter(fileName, append);
+			f1.write(fileData);
+			f1.close();
+			return true;
+		} catch (IOException e) {
+			System.out.println("Fehler beim Erstellen der Datei");
+		}
+		return false;
+	}
+
+}
diff --git a/src/main/java/de/tvo/files/DeleteFile.java b/src/main/java/de/tvo/files/DeleteFile.java
new file mode 100644
index 0000000..2b5f99d
--- /dev/null
+++ b/src/main/java/de/tvo/files/DeleteFile.java
@@ -0,0 +1,30 @@
+package de.tvo.files;
+
+import java.io.File;
+
+public class DeleteFile {
+
+	public DeleteFile() {
+		// TODO Auto-generated constructor stub
+	}
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+	
+	/**
+	 * Deleting a File
+	 * @param file filename (inc. path) to be deleted
+	 * @return true : file deleted. false : file could not be deleted
+	 */
+	public static boolean deleteFile(String file) {
+		try {
+			return new File(file).delete();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return false;
+	}
+
+}
diff --git a/src/main/java/de/tvo/files/LoadFile.java b/src/main/java/de/tvo/files/LoadFile.java
new file mode 100644
index 0000000..04727f0
--- /dev/null
+++ b/src/main/java/de/tvo/files/LoadFile.java
@@ -0,0 +1,93 @@
+package de.tvo.files;
+
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class LoadFile {
+
+	public LoadFile() {
+		
+	}
+
+	public static void main(String[] args) {
+		
+
+	}
+	
+	/**
+	 * Returns a text file with given encoding as StringArray by line
+	 * @param fileName filename (inc. path) to be read
+	 * @param fileEncoding the encoding used by the file
+	 * @return Text of file in StringArray 
+	 * @throws IOException File not Found
+	 * @author miroslav.korbel
+	 */
+	public static String[] readFileAsStringArray(String fileName, String fileEncoding) throws IOException {
+		List<String> lines = new ArrayList<String>();
+		Scanner scanner = new Scanner(new FileInputStream(fileName), fileEncoding);
+		try {
+			while (scanner.hasNextLine()) {
+				lines.add(scanner.nextLine());
+			}
+		} finally {
+			scanner.close();
+		}
+		return lines.toArray(new String[lines.size()]);
+	}
+
+	/**
+	 * Returns a text file as String
+	 * @param fileName filename (inc. path) to be read
+	 * @param debug true : Some Console output. False : No console output
+	 * @return
+	 */
+	public static String loadFile(String fileName, boolean debug) {
+		StringBuilder configBuf = new StringBuilder();
+		int c;
+		try {
+			FileReader f = new FileReader(fileName);
+			while ((c = f.read()) != -1) {
+				configBuf.append((char) c);
+			}
+			f.close();
+		} catch (IOException e) {
+			System.out.println("Fehler beim Lesen der Datei");
+		}
+
+		if (debug)
+			System.out.println(configBuf.toString());
+
+		return configBuf.toString();
+	}
+
+	/**
+	 * Load File
+	 * 
+	 * @param aFileName
+	 * @return
+	 */
+	public static StringBuffer loadFile(String aFileName) {
+		StringBuffer configBuf = new StringBuffer();
+
+		FileReader f;
+		int c;
+
+		try {
+			f = new FileReader(aFileName);
+			while ((c = f.read()) != -1) {
+				configBuf.append((char) c);
+			}
+			f.close();
+		} catch (IOException e) {
+			System.out.println("Fehler beim Lesen der Datei");
+		}
+
+		return configBuf;
+	}
+
+
+}
diff --git a/src/main/java/de/tvo/global/PreparedStatementData.java b/src/main/java/de/tvo/global/PreparedStatementData.java
new file mode 100644
index 0000000..953b679
--- /dev/null
+++ b/src/main/java/de/tvo/global/PreparedStatementData.java
@@ -0,0 +1,42 @@
+package de.tvo.global;
+
+import java.util.LinkedHashMap;
+
+public class PreparedStatementData extends LinkedHashMap<Integer, Object> {
+
+	private static final long serialVersionUID = 1L;
+//	private HashMap<String, Integer> m_fieldNameParameterID = null;
+//	public HashMap<String, Integer> getFieldNameParameterID() {
+//		if (m_fieldNameParameterID == null) {
+//			m_fieldNameParameterID = new HashMap<String, Integer>();
+//		}
+//		return m_fieldNameParameterID;
+//	}
+
+	public void addParameter(Object data) {
+		int count = 0;
+		count = this.size();
+		count++;
+		this.put(count, data);
+	}
+	
+//	public void addParameter(String fieldname, Object data) {
+//		int count = 0;
+//		count = this.size();
+//		count++;
+//		this.put(count, data);
+//		getFieldNameParameterID().put(fieldname, count);
+//	}
+//	
+//	public Object getByFieldName(String fieldname) {
+//		Object result = null;
+//		
+//		Integer id = getFieldNameParameterID().get(fieldname);
+//		
+//		if (id != null) {
+//			result = this.get(id);
+//		}
+//		return result;
+//	}
+	
+}
diff --git a/src/main/java/de/tvo/global/ProgramRightGroup.java b/src/main/java/de/tvo/global/ProgramRightGroup.java
new file mode 100644
index 0000000..4243ee0
--- /dev/null
+++ b/src/main/java/de/tvo/global/ProgramRightGroup.java
@@ -0,0 +1,32 @@
+package de.tvo.global;
+
+/**
+ * DE: 
+ *
+ * EN: 
+ * 
+ * 
+ * Program changes
+ * **************************************************************************************
+ * Date			* Ticket	* KonzFirm	* Responsible	* programmer    *
+ * Change										*
+ * **************************************************************************************
+ *
+ * @author VogelT
+ * @version 1.0
+ *
+ */
+
+public enum ProgramRightGroup {
+	
+	SUPERUSER, // Alle Rechte
+	EDV_ADMIN, // Fast alle Rechte
+	
+	KDE_ADMIN, // Kunden Admin. Bekommt User und Groups
+	USER, // Wird erst mal nicht benutzt.
+	DUMMY, // :-)
+	
+	
+	;
+
+}
diff --git a/src/main/java/de/tvo/images/ImageScale.java b/src/main/java/de/tvo/images/ImageScale.java
new file mode 100644
index 0000000..9f948bf
--- /dev/null
+++ b/src/main/java/de/tvo/images/ImageScale.java
@@ -0,0 +1,125 @@
+package de.tvo.images;
+
+import java.awt.Dimension;
+import java.awt.Graphics2D;
+import java.awt.RenderingHints;
+import java.awt.image.BufferedImage;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.imageio.ImageIO;
+
+public class ImageScale {
+
+	public ImageScale() {
+		
+	}
+
+	public static byte[] scaler(byte[] imageData, int width, int height) throws IOException {
+		byte[] data = null;
+		
+		Dimension dimension = new Dimension(width, height);
+		BufferedImage bImageFromConvert = convertBufferdImageFromByteArray(imageData);
+		
+		@SuppressWarnings("resource")
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		try {
+			ImageIO.write(scaleImage(bImageFromConvert, dimension), "jpg", baos);
+			baos.flush();
+			data = baos.toByteArray();
+
+			return data;
+			
+		} catch (Exception e) {
+			throw e;
+		} finally {
+			baos.close();	
+		}
+	}
+	
+	
+	public static BufferedImage convertBufferdImageFromByteArray(byte[] data) throws IOException {
+		InputStream in = new ByteArrayInputStream(data	);
+		BufferedImage bImageFromConvert = ImageIO.read(in);
+		return bImageFromConvert;
+	}
+	
+	public static byte[] convertByteArrayFromBufferedImage(BufferedImage bufferedImage) throws IOException {
+		byte[] data = null;
+		@SuppressWarnings("resource")
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		
+		try {
+			ImageIO.write(bufferedImage, "jpg", baos);
+			baos.flush();
+			data = baos.toByteArray();
+
+			return data;
+		} catch (Exception e) {
+
+			throw e;
+		} finally {
+			baos.close();	
+		}
+	}
+	
+
+    public static BufferedImage scaleImage(BufferedImage img, Dimension d) {
+        img = scaleByHalf(img, d);
+        img = scaleExact(img, d);
+        return img;
+    }
+
+    private static BufferedImage scaleByHalf(BufferedImage img, Dimension d) {
+        int w = img.getWidth();
+        int h = img.getHeight();
+        float factor = getBinFactor(w, h, d);
+
+        // make new size
+        w *= factor;
+        h *= factor;
+        BufferedImage scaled = new BufferedImage(w, h,
+                BufferedImage.TYPE_INT_RGB);
+        Graphics2D g = scaled.createGraphics();
+        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
+        g.drawImage(img, 0, 0, w, h, null);
+        g.dispose();
+        return scaled;
+    }
+
+    private static BufferedImage scaleExact(BufferedImage img, Dimension d) {
+        float factor = getFactor(img.getWidth(), img.getHeight(), d);
+
+        // create the image
+        int w = (int) (img.getWidth() * factor);
+        int h = (int) (img.getHeight() * factor);
+        BufferedImage scaled = new BufferedImage(w, h,
+                BufferedImage.TYPE_INT_RGB);
+
+        Graphics2D g = scaled.createGraphics();
+        g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+        g.drawImage(img, 0, 0, w, h, null);
+        g.dispose();
+        return scaled;
+    }
+
+    static float getBinFactor(int width, int height, Dimension dim) {
+        float factor = 1;
+        float target = getFactor(width, height, dim);
+        if (target <= 1) { while (factor / 2 > target) { factor /= 2; }
+        } else { while (factor * 2 < target) { factor *= 2; }         }
+        return factor;
+    }
+
+    static float getFactor(int width, int height, Dimension dim) {
+        float sx = dim.width / (float) width;
+        float sy = dim.height / (float) height;
+        return Math.min(sx, sy);
+    }
+	
+	
+}
diff --git a/src/main/java/de/tvo/json/JsonUtil.java b/src/main/java/de/tvo/json/JsonUtil.java
new file mode 100644
index 0000000..83eba24
--- /dev/null
+++ b/src/main/java/de/tvo/json/JsonUtil.java
@@ -0,0 +1,69 @@
+package de.tvo.json;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.hibernate.mapping.Map;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonParser;
+
+public abstract class JsonUtil {
+	
+	/**
+	 * Convert an object to a JSON-String
+	 * @param obj
+	 * @return
+	 */
+	public static final String objectToJson(final Object obj) {
+		return new Gson().toJson(obj);
+	}
+	
+	/**
+	 * Convert a JSON-String to a new object
+	 * @param jsonString
+	 * @param clazz
+	 * @return Object from JSON-String
+	 */
+	public static final Object jsonToObject(final String jsonString, final Class<?> clazz) {
+		return new Gson().fromJson(jsonString, clazz);
+	}
+	
+	/**
+	 * Converts a JSON-String to a map
+	 * @param jsonString
+	 * @return JSON-String as map
+	 */
+	public static final Map jsonToMap(final String jsonString) {
+		return new Gson().fromJson(jsonString, Map.class);
+	}
+	
+	/**
+	 * Pretty print JSON
+	 * @param uglyJson a JSON-String
+	 * @return pretty version of the JSON-String
+	 */
+	public static final String prettyPrintJson(final String uglyJson) {
+		 return new GsonBuilder().setPrettyPrinting().create().toJson(new JsonParser().parse(uglyJson));
+	}
+	
+	/**
+	 * Converts a simple JSON-String of numbers to an int-array
+	 * @param jsonString [123123,4534543,56756756,56756756]
+	 * @return int[]
+	 */
+	public static final int[] jsonStringOfIntegerToIntArray(final String jsonString) {
+		return Arrays.stream(jsonString.substring(1, jsonString.length()-1).split(",")).map(String::trim).mapToInt(Integer::parseInt).toArray();
+	}
+	
+	/**
+	 * Converts a simple JSON-String of numbers to List of Integer
+	 * @param jsonString [123123,4534543,56756756,56756756]
+	 * @return List<Integer>
+	 */
+	public static final List<Integer> jsonStringOfIntegerToIntList(final String jsonString) {
+		return Arrays.stream(jsonString.substring(1, jsonString.length()-1).split(",")).map(String::trim).mapToInt(Integer::parseInt).boxed().collect(Collectors.toList());
+	}
+}
diff --git a/src/main/java/de/tvo/log4j2/Log4j2Source.java b/src/main/java/de/tvo/log4j2/Log4j2Source.java
new file mode 100644
index 0000000..ccf446d
--- /dev/null
+++ b/src/main/java/de/tvo/log4j2/Log4j2Source.java
@@ -0,0 +1,9 @@
+package de.tvo.log4j2;
+
+public enum Log4j2Source {
+	SYSTEM, 
+	DATABASE, 
+	TOOLS, 
+	PROGRAM,
+	;
+}
diff --git a/src/main/java/de/tvo/network/SimplePing.java b/src/main/java/de/tvo/network/SimplePing.java
new file mode 100644
index 0000000..c6eb88f
--- /dev/null
+++ b/src/main/java/de/tvo/network/SimplePing.java
@@ -0,0 +1,76 @@
+package de.tvo.network;
+
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.Socket;
+import java.util.Date;
+
+public class SimplePing
+{
+	
+	public static void main( String[] args ) {
+		SimplePing ping = new SimplePing();
+		System.out.println(ping.ping("localhost", 8080));
+	}
+	
+	/*
+  public static void main( String[] args )
+  {
+    System.out.println( "\nUsage: java SimplePing host [port] \n" +
+                        "   or: java SimplePing 1.2.3.4 80 \n" );
+    try {
+      if( args.length <= 0 )
+        throw new Exception( "Parameter missing!" );
+      InetAddress host = InetAddress.getByName( args[0] );
+      int         port = ( args.length > 1 ) ? Integer.parseInt( args[1] ) : 80;
+      long        tm   = System.nanoTime();
+      Socket      so   = new Socket( host, port );
+      so.setSoTimeout(500);
+      
+      so.close();
+      tm = (System.nanoTime() - tm) / 1000000L;
+      System.out.println( "Connection ok (port " + port + ", time = " + tm + " ms). \n" +
+                          "Host Address = " + host.getHostAddress() + "\n" +
+                          "Host Name    = " + host.getHostName() );
+      System.exit( 0 );
+    } catch( Exception ex ) {
+      System.out.println( "Error: " + ex.getMessage() );
+      System.exit( 1 );
+    }
+  }
+  */
+  
+  public boolean ping(String host, int port) {
+	  boolean aktiv = true;
+	  Date date = new Date();
+	  int timeout = 5000;
+	  try {
+		  
+		  
+		  
+		  System.out.println(date);
+	      InetAddress hostAdress = InetAddress.getByName( host );
+	      long        tm   = System.nanoTime();
+	      
+	      Socket socket = new Socket();
+	      // This limits the time allowed to establish a connection in the case
+	      // that the connection is refused or server doesn't exist.
+	      socket.connect(new InetSocketAddress(host, port), timeout);
+	      // This stops the request from dragging on after connection succeeds.
+	      socket.setSoTimeout(timeout);
+	      socket.close();
+	      
+	      tm = (System.nanoTime() - tm) / 1000000L;
+		
+	} catch (Exception e) {
+		aktiv = false;
+		date = new Date();
+	    System.out.println( "Error: " + e.getMessage() + " --> " + date );
+	}
+
+	  
+	  
+	  return aktiv;
+  }
+  
+}
\ No newline at end of file
diff --git a/src/main/java/de/tvo/network/UrlCheck.java b/src/main/java/de/tvo/network/UrlCheck.java
new file mode 100644
index 0000000..30478cf
--- /dev/null
+++ b/src/main/java/de/tvo/network/UrlCheck.java
@@ -0,0 +1,35 @@
+package de.tvo.network;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+public class UrlCheck {
+
+	public UrlCheck() {
+		// TODO Auto-generated constructor stub
+	}
+
+	public static void main(String[] args) {
+
+		System.out.println(istVorhanden(""));
+		
+		
+
+	}
+	
+	public static boolean istVorhanden(String link){
+	    URL url = null;
+	    try {
+	        url = new URL(link);
+	    } catch (MalformedURLException e1) {
+	        e1.printStackTrace();
+	    }
+	        try {
+	        url.openStream().close();
+	            return true;
+	        } catch (Exception e) {
+	            return false;
+	        } 
+	}
+
+}
diff --git a/src/main/java/de/tvo/reflection/MyObject.java b/src/main/java/de/tvo/reflection/MyObject.java
new file mode 100644
index 0000000..800377d
--- /dev/null
+++ b/src/main/java/de/tvo/reflection/MyObject.java
@@ -0,0 +1,408 @@
+package de.tvo.reflection;
+
+import java.beans.Introspector;
+import java.beans.PropertyDescriptor;
+import java.io.Serializable;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import de.tvo.tools.StringUtil;
+
+
+
+public class MyObject extends Object implements Serializable {
+
+	private static final long serialVersionUID = 1L;
+	
+	private Object object = new Object();
+	public Object getObject() { return object; }
+	public void setObject(Object object) { this.object = object; }
+
+
+	public MyObject(Object obj) {
+		 setObject(obj);
+	}
+	
+	public MyObject() {
+		 object = new Object();
+	}
+	
+	public void set(String fieldname, Object value) {
+		
+		try {
+			if (value != null) {
+				Field field = null;
+				
+				try {
+					field = getObject().getClass().getDeclaredField(fieldname.toLowerCase());	
+					field.setAccessible(true);
+				} catch (Exception e) {
+					field = getObject().getClass().getField(fieldname.toLowerCase());
+				}
+				
+				if (field == null) {
+					return;
+				}
+				
+				
+				//System.out.println(this.getClass().getField(fieldname.toLowerCase()).getType().getName());
+				
+				if (field.getType().getName().equals("java.lang.String")  ) {
+					//System.out.println("--> java.lang.String");
+					field.set(getObject(), value);	
+					
+				} else if (field.getType().getName().equals("java.lang.Long")  ) {
+					//System.out.println("--> java.lang.Long");
+					
+					if (StringUtil.safeIsBlankObj(value))
+						value = 0;
+					
+					field.set(getObject(), Long.parseLong(value.toString()));	
+				} else if (field.getType().getName().equals("java.lang.Integer")  ) {
+					//System.out.println("--> java.lang.Integer");
+					if (value.toString().trim().length() == 0)
+						value = 0;
+					
+					field.set(getObject(), Integer.parseInt(value.toString()));	
+				} else if (field.getType().getName().equals("java.lang.Double")  ) {
+					//System.out.println("--> java.lang.Double");
+					if (value.toString().trim().length() == 0)
+						value = 0.0;
+					
+					field.set(getObject(), Double.parseDouble(value.toString()));	
+				}  else if (field.getType().getName().equals("java.util.Date")  ) {
+					//System.out.println("--> java.util.Date !!! ACHTUNG!!!");
+					
+					//getObject().getClass().getField(fieldname.toLowerCase()).set(getObject(), Double.parseDouble(value.toString()));	
+				} else {
+					field.set(getObject(), value);
+				}
+				
+				
+				
+			}
+			
+			
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	
+	
+	public Object get(String fieldname) {
+		Object result = null;
+	
+		try {
+			//System.out.println("this.getClass().getField(fieldname).getName(): " + this.getClass().getField(fieldname).getName());
+		
+			if (fieldname == null || fieldname.trim().length() == 0)
+				return "";
+			
+			
+			result = ReflectionUtil.getValueOf(getObject(), fieldname);	
+		
+			
+			if (result == null)
+			result = "";
+		
+		
+		} catch (Exception e) {
+			e.printStackTrace();
+			//LogHandler.logError(this.getClass().getSimpleName(), e, "get() ", "");
+			return "";
+		}
+		return result;
+	}
+
+	public String getType(String fieldname) {
+		String result = null;
+		try {
+			
+			if (fieldname == null || fieldname.trim().length() == 0)
+				return "";
+			
+			Field field = null;
+			
+			try {
+				field = getObject().getClass().getDeclaredField(fieldname.toLowerCase());
+				field.setAccessible(true);
+			} catch (Exception e) {
+				field = getObject().getClass().getField(fieldname.toLowerCase());
+			}
+			
+			if (field == null) {
+				return "";
+			}
+			
+			
+			result = field.getType().getName();	
+		} catch (Exception e) {
+			e.printStackTrace();
+			//LogHandler.logError(getObject().getClass().getSimpleName(), e, "getType --> " + fieldname, "");
+			return "";
+		}
+		return result;
+	}
+	
+	
+    public Object[] createArrayFromObject(Object obj) {
+    	Object[] result = null;
+    	
+    	try {
+    		
+    		setObject(obj);
+    		
+    		Field[] objFields = getObject().getClass().getDeclaredFields();
+    		
+    		result = new Object[objFields.length];
+    		
+    		for (int fd = 0; fd < objFields.length; fd++) {
+    			String fieldname = null;
+    			fieldname = objFields[fd].getName();
+    			
+    			result[fd] = this.get(fieldname);
+    			
+    		}
+			
+		} catch (Exception e) {
+			e.printStackTrace();
+			//LogHandler.logError(this.getClass().getSimpleName(), e, "createArrayFromObject", "keiner");
+		}
+		return result;
+	}
+    
+    
+    /** Trimmt alle Strings, die innerhalb eines Objekts
+     * @see #trimReflectiveString
+     *  
+    **/
+    
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public static <T> T trimReflective(T object) throws Exception {
+        if (object == null)
+            return null;
+
+        Class<? extends Object> c = object.getClass();
+        try {
+            // Introspector usage to pick the getters conveniently thereby
+            // excluding the Object getters
+            for (PropertyDescriptor propertyDescriptor : Introspector
+                    .getBeanInfo(c, Object.class).getPropertyDescriptors()) {
+                Method method = propertyDescriptor.getReadMethod();
+                String name = method.getName();
+
+                // If the current level of Property is of type String
+                if (method.getReturnType().equals(String.class)) {
+                    String property = (String) method.invoke(object);
+                    if (property != null) {
+                        Method setter = c.getMethod("set" + name.substring(3),
+                                new Class<?>[] { String.class });
+                        if (setter != null)
+                            // Setter to trim and set the trimmed String value
+                            setter.invoke(object, property.trim());
+                    }
+                }
+
+                // If an Object Array of Properties - added additional check to
+                // avoid getBytes returning a byte[] and process
+                if (method.getReturnType().isArray()
+                        && !method.getReturnType().isPrimitive()
+                        && !method.getReturnType().equals(String[].class)
+                        && !method.getReturnType().equals(byte[].class)) {
+                    System.out.println(method.getReturnType());
+                    // Type check for primitive arrays (would fail typecasting
+                    // in case of int[], char[] etc)
+                    if (method.invoke(object) instanceof Object[]) {
+                        Object[] objectArray = (Object[]) method.invoke(object);
+                        if (objectArray != null) {
+                            for (Object obj : (Object[]) objectArray) {
+                                // Recursively revisit with the current property
+                                trimReflective(obj);
+                            }
+                        }
+                    }
+                }
+                // If a String array
+                if (method.getReturnType().equals(String[].class)) {
+                    String[] propertyArray = (String[]) method.invoke(object);
+                    if (propertyArray != null) {
+                        Method setter = c.getMethod("set" + name.substring(3),
+                                new Class<?>[] { String[].class });
+                        if (setter != null) {
+                            String[] modifiedArray = new String[propertyArray.length];
+                            for (int i = 0; i < propertyArray.length; i++)
+                                if (propertyArray[i] != null)
+                                    modifiedArray[i] = propertyArray[i].trim();
+
+                            // Explicit wrapping
+                            setter.invoke(object,
+                                    new Object[] { modifiedArray });
+                        }
+                    }
+                }
+                // Collections start
+                if (Collection.class.isAssignableFrom(method.getReturnType())) {
+                    Collection collectionProperty = (Collection) method
+                            .invoke(object);
+                    if (collectionProperty != null) {
+                        for (int index = 0; index < collectionProperty.size(); index++) {
+                            if (collectionProperty.toArray()[index] instanceof String) {
+                                String element = (String) collectionProperty
+                                        .toArray()[index];
+
+                                if (element != null) {
+                                    // Check if List was created with
+                                    // Arrays.asList (non-resizable Array)
+                                    if (collectionProperty instanceof List) {
+                                        ((List) collectionProperty).set(index,
+                                        		StringUtil.safeTrimObj(element));
+                                    } else {
+                                        collectionProperty.remove(element);
+                                        collectionProperty.add(StringUtil.safeTrimObj(element));
+                                    }
+                                }
+                            } else {
+                                // Recursively revisit with the current property
+                                trimReflective(collectionProperty.toArray()[index]);
+                            }
+                        }
+                    }
+                }
+                // Separate placement for Map with special conditions to process
+                // keys and values
+                if (method.getReturnType().equals(Map.class)) {
+                    Map mapProperty = (Map) method.invoke(object);
+                    if (mapProperty != null) {
+                        // Keys
+                        for (int index = 0; index < mapProperty.keySet().size(); index++) {
+                            if (mapProperty.keySet().toArray()[index] instanceof String) {
+                                String element = (String) mapProperty.keySet()
+                                        .toArray()[index];
+                                if (element != null) {
+                                    mapProperty.put(StringUtil.safeTrimObj(element),
+                                            mapProperty.get(element));
+                                    mapProperty.remove(element);
+                                }
+                            } else {
+                                // Recursively revisit with the current property
+                                trimReflective(mapProperty.get(index));
+                            }
+
+                        }
+                        // Values
+                        for (Map.Entry entry : (Set<Map.Entry>) mapProperty
+                                .entrySet()) {
+
+                            if (entry.getValue() instanceof String) {
+                                String element = (String) entry.getValue();
+                                if (element != null) {
+                                    entry.setValue(StringUtil.safeTrimObj(element));
+                                }
+                            } else {
+                                // Recursively revisit with the current property
+                                trimReflective(entry.getValue());
+                            }
+                        }
+                    }
+                } else {
+                    Object property = (Object) method.invoke(object);
+                    if (property != null) {
+                        trimReflective(property);
+                    }
+                }
+            }
+
+        } catch (Exception e) {
+            throw new Exception("Strings nicht getrimmt : ", e);
+        }
+
+        return object;
+
+    }
+	
+	/**
+	 * 
+	 * <p>Info: Performanter als normaler #trimReflective</p>
+	 * @see #trimReflective
+	 * @param <T>
+	 * @param object
+	 * @return Trimmed Object
+	 * @throws Exception
+	 */
+	
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public static <T> T trimReflectiveString(T object) throws Exception {
+        if (object == null) {
+        	return null;
+        }
+
+        Class<? extends Object> c = object.getClass();
+        try {
+            // Introspector usage to pick the getters conveniently thereby
+            // excluding the Object getters
+            for (PropertyDescriptor propertyDescriptor : Introspector
+                    .getBeanInfo(c, Object.class).getPropertyDescriptors()) {
+                Method method = propertyDescriptor.getReadMethod();
+                String name = method.getName();
+
+                // If the current level of Property is of type String
+                if (method.getReturnType().equals(String.class)) {
+                    String property = (String) method.invoke(object);
+                    if (property != null) {
+                        Method setter = c.getMethod("set" + name.substring(3),
+                                new Class<?>[] { String.class });
+                        if (setter != null)
+                            // Setter to trim and set the trimmed String value
+                            setter.invoke(object, property.trim());
+                    }
+                }
+            }
+        } catch (Exception e) {
+            throw new Exception("Strings nicht getrimmt : ", e);
+        }
+
+        return object;
+
+    }
+	
+	public static List<?> trimReflectiveListString(List<?> object) throws Exception {
+		return object.stream().map(t -> {
+			try {
+				return MyObject.trimReflectiveString(t);
+			} catch (Exception e) {
+				e.printStackTrace();
+				return null;
+			}
+		}).collect(Collectors.toList());
+	}
+	
+	public static List<Object[]> trimReflectiveObjectListString(List<Object[]> list) throws Exception {
+		return list.stream().map(t -> {
+			try {
+				return MyObject.trimReflectiveString(t);
+			} catch (Exception e) {
+				e.printStackTrace();
+				return null;
+			}
+		}).collect(Collectors.toList());
+	}
+	
+	public static List<Object[]> trimReflectiveObject(List<Object[]> list){
+		list.stream()
+		.flatMap(Arrays::stream)
+		.forEach(t -> {
+			try {
+				MyObject.trimReflectiveString(t);
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+		});
+		return list;
+	}
+}
diff --git a/src/main/java/de/tvo/reflection/ReflectClass.java b/src/main/java/de/tvo/reflection/ReflectClass.java
new file mode 100644
index 0000000..1804cd3
--- /dev/null
+++ b/src/main/java/de/tvo/reflection/ReflectClass.java
@@ -0,0 +1,281 @@
+package de.tvo.reflection;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 
+ * @author VogelT
+ *
+ */
+
+public class ReflectClass {
+
+	private final Object m_workObject;
+	public Object getWorkObject() { return m_workObject; }
+	
+	public void setMethod(String method) {
+		setMethod(method, null);
+	}
+	
+	/**
+	 * 
+	 * @param method
+	 * @param arg
+	 */
+	public void setMethod(String method, Object arg) {
+		setMethod(method, new Object[]{arg});
+	}
+	
+	/**
+	 * 
+	 * @param method
+	 * @param arg
+	 */
+	public void setMethod(String method, Object[] arg) {
+		try {
+        	
+        	@SuppressWarnings("rawtypes")
+			Class[] parameterTypes = getParameterTypes(method);
+        	Method setter = getWorkObject().getClass().getMethod(method, parameterTypes);
+
+        	if (arg != null) {
+        		setter.invoke(getWorkObject(), arg);
+        	} else {
+        		setter.invoke(getWorkObject());
+        	}
+        	
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+	}
+	
+	public Object getMethod(String method) {
+		return getMethod(method, null);
+	}
+	
+	public Object getMethod(String method, Object[] arg) {
+		Object result = null;
+		try {
+        	
+        	@SuppressWarnings("rawtypes")
+			Class[] parameterTypes = getParameterTypes(method);
+        	Method setter = getWorkObject().getClass().getMethod(method, parameterTypes);
+
+        	if (arg != null) {
+        		result = setter.invoke(getWorkObject(), arg);
+        	} else {
+        		result = setter.invoke(getWorkObject());
+        	}
+        	
+        	return result;
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return null;
+	}
+	
+	public void set(String fieldname, Object value) {
+		try {
+			Field field = getWorkObject().getClass().getDeclaredField(fieldname);
+			
+			if (field == null) {
+				field = getWorkObject().getClass().getField(fieldname);
+				
+			}
+			field.setAccessible(true);
+			field.set(getWorkObject(), value);
+			
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		
+	}
+	
+	public Object get(String fieldname) {
+		Object result = null;
+		//System.out.println("Fieldname: " + fieldname);
+		
+		if (getUpperSearch()) {
+			fieldname = fieldname.trim().toUpperCase();
+		} else {
+			fieldname = fieldname.trim().toLowerCase();
+		}
+		
+		try {
+			if(fieldname.startsWith("serial")) {
+				return result;
+			}
+			
+			Field field = getWorkObject().getClass().getDeclaredField(fieldname);
+			
+			//String clazzType = field.getType().getName();
+			if (field == null) {
+				field = getWorkObject().getClass().getField(fieldname);
+			}
+			
+			if (field != null) {
+				field.setAccessible(true);
+				result = field.get(getWorkObject());
+			}
+					
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return result;
+	}
+	
+	/**
+	 * 
+	 * @param method
+	 * @return
+	 */
+//	public Object getMethod(String method) {
+//		Object result = null;
+//		
+//		try {
+//	
+//			
+//			
+//		} catch (Exception e) {
+//			e.printStackTrace();
+//		}
+//		return result;
+//	}
+	
+	/**
+	 * 
+	 * @param methodSearch
+	 * @return
+	 */
+	public Class<?> getReturnType(String methodSearch) {
+		Class<?> returnTypes = null;
+		
+		for ( Method method : getWorkObject().getClass().getMethods() ) {
+	      //String returnString = method.getReturnType().getName();
+
+	      if (method.getName().equals(methodSearch)) {
+	    	  returnTypes = method.getReturnType();
+	    	  break;
+	      }
+		}
+	    return returnTypes;
+	}
+	
+	/**
+	 * 
+	 * @param methodSearch
+	 * @return
+	 */
+	public Class<?>[] getParameterTypes(String methodSearch) {
+		Class<?>[] parameterTypes = null;
+		
+		for ( Method method : getWorkObject().getClass().getMethods() ) {
+	      //String returnString = method.getReturnType().getName();
+
+	      if (method.getName().equals(methodSearch)) {
+	    	  parameterTypes = method.getParameterTypes();
+	    	  break;
+	      }
+	    }
+		return parameterTypes;
+	}
+
+	/**
+	 * showMethods
+	 */
+	public void showMethods() {
+	    for ( Method method : getWorkObject().getClass().getMethods() ) {
+	      String returnString = method.getReturnType().getName();
+	      System.out.print( returnString + " " + method.getName() + "(" );
+
+	      Class<?>[] parameterTypes = method.getParameterTypes();
+
+	      for ( int k = 0; k < parameterTypes.length; k++ ) {
+	        String parameterString = parameterTypes[k].getName();
+	        System.out.print( " " + parameterString );
+
+	        if ( k < parameterTypes.length - 1 )
+	          System.out.print( ", " );
+	      }
+	      System.out.print( " )" );
+
+	      Class<?>[] exceptions = method.getExceptionTypes();
+
+	      if ( exceptions.length > 0 ) {
+	        System.out.print( " throws " );
+	        for ( int k = 0; k < exceptions.length; k++ ) {
+	          System.out.print( exceptions[k].getName() );
+	          if ( k < exceptions.length - 1)
+	            System.out.print( ", " );
+	        }
+	      }
+	      System.out.println();
+	    }
+	}
+
+	public boolean m_upperSearch = false;
+	public boolean getUpperSearch() { return m_upperSearch; }
+
+	public ReflectClass(Object o) {
+		this.m_workObject = o;
+
+	}
+	
+	public ReflectClass(Object o, boolean upperSearch) {
+		this.m_workObject = o;
+		this.m_upperSearch = upperSearch;
+	}
+	
+	public static void main(String[] arg) {
+		
+//		MenuBarButtonExpressions barExpressions = new MenuBarButtonExpressions(MenuBarButtonAction.PRINT, "Text", "/image");
+//		ReflectClass reflectClass = new ReflectClass(barExpressions);
+//		reflectClass.showMethods();
+//		
+//		reflectClass.showFields();
+		
+	}
+
+	public void showFields() {
+		
+		Field[] fields = getWorkObject().getClass().getDeclaredFields();
+		
+		for (Field field : fields) {
+			System.out.println(field.getName());
+		}
+		
+	}
+	
+	public List<String> getAllFields() {
+		List<String> resultList = new ArrayList<String>();
+		Field[] fields = getWorkObject().getClass().getDeclaredFields();
+		
+		for (Field field : fields) {
+			resultList.add(field.getName());
+		}
+		return resultList;
+	}
+	
+	public String getType(String fieldname) {
+		String result = null;
+		try {
+			
+			if (fieldname == null || fieldname.trim().length() == 0)
+				return "";
+			
+			if (getUpperSearch()) {
+				result = getWorkObject().getClass().getDeclaredField(fieldname.trim().toUpperCase()).getType().getName();
+			} else {
+				result = getWorkObject().getClass().getDeclaredField(fieldname.trim().toLowerCase()).getType().getName();	
+			}
+		} catch (Exception e) {
+			e.printStackTrace();
+			return "";
+		}
+		return result;
+	}
+
+}
diff --git a/src/main/java/de/tvo/reflection/ReflectionUtil.java b/src/main/java/de/tvo/reflection/ReflectionUtil.java
new file mode 100644
index 0000000..34bfebe
--- /dev/null
+++ b/src/main/java/de/tvo/reflection/ReflectionUtil.java
@@ -0,0 +1,85 @@
+package de.tvo.reflection;
+
+import java.lang.reflect.Field;
+
+public class ReflectionUtil {
+	
+	public static void objectToConsole(final Object obj) {
+		try {
+			for (final Field field : obj.getClass().getDeclaredFields()) {
+				try {
+					if (!field.isAccessible()) {
+						field.setAccessible(true);
+					}
+					Object value = field.get(obj);
+					System.out.println("variable: \"" + field.getName() + "\", value: \"" + value + "\"" + field.getType());
+				} catch (final Exception e) {
+					e.printStackTrace();
+				}
+			}
+		} catch (final Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+	public ReflectionUtil() {
+
+	}
+	
+	public static Object getValueOf(Object clazz, String lookingForValue) throws Exception {
+		Object result = null;
+		
+		Field field = clazz.getClass().getDeclaredField(lookingForValue);
+		field.setAccessible(true);
+		//Class clazzType = field.getType();
+		String clazzType = field.getType().getName();
+		Object value = null;
+		//System.out.println("Typen: --> " + clazzType.toString() + "| " + field.get(clazz) + "|");
+		
+		if (clazzType.equals("java.lang.Double")) {
+			//System.out.println("java.lang.Double");
+			//return field.getDouble(clazz);
+			return Double.parseDouble(field.get(clazz).toString().trim());
+		} else if (clazzType.equals("java.lang.Integer")) {
+			//System.out.println("java.lang.Integer");
+			//return field.getInt(clazz);
+			value = field.get(clazz);
+			
+			if (value == null)
+				value = 0;
+			return Integer.parseInt(value.toString().trim());
+		} else if (clazzType.equals("java.lang.Long")) {
+			//System.out.println("java.lang.Long");
+			//return field.getLong(clazz);
+			value = field.get(clazz);
+			
+			if (value == null)
+				value = 0L;
+			
+			return Long.parseLong(value.toString().trim());
+		} else if (clazzType.equals("java.lang.String")) {
+			value = field.get(clazz);
+			
+			//System.out.println("value: " + value);
+			
+			if (value == null)
+				value = "";
+			
+			return value;
+		}
+		
+		// else other type ...
+		// and finally
+		
+		//System.out.println("clazz " + clazz);
+		//System.out.println("field " + field.getName());
+		
+		result = field.get(clazz);
+		
+		if (result == null)
+			result = "";
+		
+		return result;
+	}
+
+}
diff --git a/src/main/java/de/tvo/tools/ArrayUtil.java b/src/main/java/de/tvo/tools/ArrayUtil.java
new file mode 100644
index 0000000..6915d2a
--- /dev/null
+++ b/src/main/java/de/tvo/tools/ArrayUtil.java
@@ -0,0 +1,182 @@
+package de.tvo.tools;
+
+import static java.lang.String.format;
+
+import java.io.PrintStream;
+
+public class ArrayUtil {
+
+	public final static String prettyPrintObjectArray(final Object[][] objArrr, boolean printOut) {
+		String[][] stringArr = new String[objArrr.length][0];
+		for (int i = 0; i < objArrr.length; ++i) {
+			stringArr[i] = new String[objArrr[i].length];
+			for (int j = 0; j < objArrr[i].length; ++j) {
+				stringArr[i][j] = StringUtil.safeTrimObj(objArrr[i][j]);
+			}
+		}
+
+		return prettyPrintStringArray(stringArr, printOut);
+	}
+
+	public final static String prettyPrintObjectArray(final Object[] objArrr, boolean printOut) {
+		String[] stringArr = new String[objArrr.length];
+		for (int i = 0; i < objArrr.length; ++i) {
+			stringArr[i] = StringUtil.safeTrimObj(objArrr[i]);
+		}
+		return prettyPrintStringArray(stringArr, printOut);
+	}
+
+	public static String prettyPrintStringArray(final String[][] stringArrr, boolean printOut) {
+		return new PrettyPrinter(System.out).print(stringArrr, printOut);
+	}
+
+	public static String prettyPrintStringArray(final String[] stringArrr, boolean printOut) {
+		return new PrettyPrinter(System.out).print(stringArrr, printOut);
+	}
+
+	private final static class PrettyPrinter {
+
+		private static final char BORDER_KNOT = '+';
+		private static final char HORIZONTAL_BORDER = '-';
+		private static final char VERTICAL_BORDER = '|';
+
+		private final PrintStream out;
+		private final String asNull = "(NULL)";
+		private final String asEmpty = "(EMPTY)";
+
+		public PrettyPrinter(PrintStream out) {
+			if (out == null) {
+				throw new IllegalArgumentException("No print stream provided");
+			}
+			this.out = out;
+		}
+
+		public String print(String[][] table, boolean printOut) {
+			if (table == null) {
+				throw new IllegalArgumentException("No tabular data provided");
+			}
+			if (table.length == 0) {
+				return "";
+			}
+			final int[] widths = new int[getMaxColumns(table)];
+			adjustColumnWidths(table, widths);
+			return printPreparedTable(table, widths, getHorizontalBorder(widths), printOut);
+		}
+
+		public String print(String[] table, boolean printOut) {
+			if (table == null) {
+				throw new IllegalArgumentException("No tabular data provided");
+			}
+			if (table.length == 0) {
+				return "";
+			}
+			final int[] widths = new int[getMaxColumns(table)];
+			adjustColumnWidths(table, widths);
+			return printPreparedTable(table, widths, getHorizontalBorder(widths), printOut);
+		}
+
+		private String printPreparedTable(String[][] table, int widths[], String horizontalBorder, boolean printOut) {
+			final int lineLength = horizontalBorder.length();
+			StringBuilder build = new StringBuilder(horizontalBorder).append("\n");
+			for (final String[] row : table) {
+				if (row != null) {
+					build.append(getRow(row, widths, lineLength)).append("\n").append(horizontalBorder).append("\n");
+				}
+			}
+			if (printOut) {
+				out.println(build.toString());
+			}
+			return build.toString();
+		}
+
+		private String printPreparedTable(String[] row, int widths[], String horizontalBorder, boolean printOut) {
+			final int lineLength = horizontalBorder.length();
+			StringBuilder build = new StringBuilder(horizontalBorder).append("\n");
+			if (row != null) {
+				build.append(getRow(row, widths, lineLength)).append("\n").append(horizontalBorder).append("\n");
+			}
+			if (printOut) {
+				out.println(build.toString());
+			}
+			return build.toString();
+		}
+
+		private String getRow(String[] row, int[] widths, int lineLength) {
+			final StringBuilder builder = new StringBuilder(lineLength).append(VERTICAL_BORDER);
+			final int maxWidths = widths.length;
+			for (int i = 0; i < maxWidths; i++) {
+				builder.append(padRight(getCellValue(safeGet(row, i, null)), widths[i])).append(VERTICAL_BORDER);
+			}
+			return builder.toString();
+		}
+
+		private String getHorizontalBorder(int[] widths) {
+			final StringBuilder builder = new StringBuilder(256);
+			builder.append(BORDER_KNOT);
+			for (final int w : widths) {
+				for (int i = 0; i < w; i++) {
+					builder.append(HORIZONTAL_BORDER);
+				}
+				builder.append(BORDER_KNOT);
+			}
+			return builder.toString();
+		}
+
+		private int getMaxColumns(String[][] rows) {
+			int max = 0;
+			for (final String[] row : rows) {
+				if (row != null && row.length > max) {
+					max = row.length;
+				}
+			}
+			return max;
+		}
+
+		private int getMaxColumns(String[] row) {
+			int max = 0;
+			if (row != null && row.length > max) {
+				max = row.length;
+			}
+			return max;
+		}
+
+		private void adjustColumnWidths(String[][] rows, int[] widths) {
+			for (final String[] row : rows) {
+				if (row != null) {
+					for (int c = 0; c < widths.length; c++) {
+						final String cv = getCellValue(safeGet(row, c, asNull));
+						final int l = cv.length();
+						if (widths[c] < l) {
+							widths[c] = l;
+						}
+					}
+				}
+			}
+		}
+
+		private void adjustColumnWidths(String[] row, int[] widths) {
+			if (row != null) {
+				for (int c = 0; c < widths.length; c++) {
+					final String cv = getCellValue(safeGet(row, c, asNull));
+					final int l = cv.length();
+					if (widths[c] < l) {
+						widths[c] = l;
+					}
+				}
+			}
+		}
+
+		private static String padRight(String s, int n) {
+			return format("%1$-" + n + "s", s);
+		}
+
+		private static String safeGet(String[] array, int index, String defaultValue) {
+			return index < array.length ? array[index] : defaultValue;
+		}
+
+		private String getCellValue(String value) {
+			return value == null ? asNull : (value.isEmpty() ? asEmpty : value);
+		}
+	}
+
+}
diff --git a/src/main/java/de/tvo/tools/ByteUtil.java b/src/main/java/de/tvo/tools/ByteUtil.java
new file mode 100644
index 0000000..362263f
--- /dev/null
+++ b/src/main/java/de/tvo/tools/ByteUtil.java
@@ -0,0 +1,18 @@
+package de.tvo.tools;
+
+public class ByteUtil {
+	
+	/**
+	 * https://stackoverflow.com/questions/3758606/how-to-convert-byte-size-into-human-readable-format-in-java
+	 * @param bytes - bytes 
+	 * @param si - kB, binary KiB
+	 * @return formatted bytes
+	 */
+	public static String humanReadableByteCount(final long bytes, final boolean si) {
+	    int unit = si ? 1000 : 1024;
+	    if (bytes < unit) return bytes + " B";
+	    int exp = (int) (Math.log(bytes) / Math.log(unit));
+	    String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp-1) + (si ? "" : "i");
+	    return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
+	}
+}
diff --git a/src/main/java/de/tvo/tools/CSVUtil.java b/src/main/java/de/tvo/tools/CSVUtil.java
new file mode 100644
index 0000000..5669b35
--- /dev/null
+++ b/src/main/java/de/tvo/tools/CSVUtil.java
@@ -0,0 +1,160 @@
+package de.tvo.tools;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+public class CSVUtil {
+	
+	public static void main(String[] args) {
+//		System.out.println(createCSVString(new String[][] {
+//			new String[] {"A", "", "", "", "B", "B", "X", "X", "B", "B", "B", "B", "B", "X"},
+//	        new String[] {"A", "", "X", "X", "B", "B", "X", "X", "B", "B", "B", "B", "B", "Y"},
+//	        new String[] {},
+//	        new String[] {"A", "", "", "T", "B", "B", "X", "X", "B", "B", "B", "B", "B", "Z"}
+//		}, ";", "\n"));
+		
+//		List<String> list1 = Arrays.asList("1", "2");
+//		List<String> list2 = Arrays.asList("1", "2", "3");
+//		List<Object> list3 = new ArrayList<>();
+//		List<List<?>> listList = new ArrayList<>();
+//		listList.add(list1);
+//		listList.add(list3);
+//		listList.add(list2);
+//		System.out.println(createCSVString(listList, ";", "\n"));
+		
+//		Map<String, List<String>> csvMap = csvToMap("Vorname;Nachname;Nummer\nVN1;;NM1\nVN2", ";", "\n");
+//		
+//		MapUtil.prettyPrintMapOfObjectList(csvMap);
+		
+//		for (String str : csvToListString("1;2;;4;;5\n\n4;5;6;\n123;2;;;", ";", "\n")) {
+//			System.out.println(str);
+//		}
+ 	}
+	
+	
+	public static String createCSVString(final String[] csvTitel, final Object[][] data, final String seperator, final String lineSeperator) {
+		final StringBuilder csvString = new StringBuilder();
+
+		for (int col = 0; col < csvTitel.length; col++) {
+			csvString.append(StringUtil.safeTrimObjWithReplace(csvTitel[col]));
+			if (col+1 < csvTitel.length) {
+				csvString.append(seperator);
+			}
+		}
+		csvString.append(lineSeperator);
+		
+		for (int row = 0; row < data.length; row++) {
+			for (int col = 0; col < data[row].length; col++) {
+				csvString.append(StringUtil.safeTrimObjWithReplace(data[row][col]));
+				if (col+1 < data[row].length) {
+					csvString.append(seperator);
+				}
+			}
+			if (data[row].length != 0 && row+1 < data.length) {
+				csvString.append(lineSeperator);
+			}
+		}
+		return csvString.toString();
+	}
+	
+	
+	/**
+	 * Creates a not escaped CSV-String based on the given arguments, empty lines will get ignored
+	 * <br>
+	 * @param data			-	2 Dimensional Object array
+	 * @param seperator		-	Seperator, usually ';'
+	 * @param lineSeperator -	Lineseparator, usually '\n' or '\r\n'
+	 * @return CSV-String
+	 */
+	public static String createCSVString(final Object[][] data, final String seperator, final String lineSeperator) {
+		final StringBuilder csvString = new StringBuilder();
+		for (int row = 0; row < data.length; row++) {
+			for (int col = 0; col < data[row].length; col++) {
+				csvString.append(StringUtil.safeTrimObjWithReplace(data[row][col]));
+				if (col+1 < data[row].length) {
+					csvString.append(seperator);
+				}
+			}
+			if (data[row].length != 0 && row+1 < data.length) {
+				csvString.append(lineSeperator);
+			}
+		}
+		return csvString.toString();
+	}
+	
+	/**
+	 * Creates a not escaped CSV-String based on the given arguments, empty lines will get ignored
+	 * <br>
+	 * @param data 			-	2 List of Lists
+	 * @param seperator 	-	Seperator, usually ';'
+	 * @param lineSeperator -	Lineseparator, usually '\n' or '\r\n'
+	 * @return CSV-String
+	 */
+	public static String createCSVString(final List<List<?>> data, final String seperator, final String lineSeperator) {
+		final StringBuilder csvString = new StringBuilder();
+		for (int row = 0; row < data.size(); row++) {
+			for (int col = 0; col < data.get(row).size(); col++) {
+				csvString.append(StringUtil.safeTrimObjWithReplace(data.get(row).get(col)));
+				if (col+1 < data.get(row).size()) {
+					csvString.append(seperator);
+				}
+			}
+			if (data.get(row).size() != 0 && row+1 < data.size()) {
+				csvString.append(lineSeperator);
+			}
+		}
+		return csvString.toString();
+	}
+
+	/**
+	 * Creates a Map which has all headlines of the CSV as keys and the related values as List&lt;String&gt; as value
+	 * <br>
+	 * @param data 			-	2 List of Lists
+	 * @param seperator 	-	Seperator, usually ';'
+	 * @param lineSeperator -	Lineseparator, usually '\n' or '\r\n'
+	 * @return Result
+	 */
+	public static Map<String, List<String>> csvToMap(final String csvString, final String seperator, final String lineSeperator) {
+		String[] lines = csvString.split(lineSeperator);
+		Map<String, List<String>> result = new LinkedHashMap<String, List<String>>();
+		List<String> headerList = new ArrayList<String>();
+		
+		for (final String header : lines[0].split(seperator)) {
+			result.put(header, new ArrayList<String>());
+			headerList.add(header);
+		}
+		for (int l = 1; l < lines.length; l++) {
+			String[] cols = lines[l].split(seperator);
+			for (int c = 0; c < cols.length; ++c) {
+				result.get(headerList.get(c)).add(StringUtil.safeTrimWithReplace(cols[c]));
+			}
+		}
+		return result;
+	}
+	
+	/**
+	 * Creates a List of Strings which contains all filled CSV-columns as values
+	 * <br>
+	 * @param data 			-	2 List of Lists
+	 * @param seperator 	-	Seperator, usually ';'
+	 * @param lineSeperator -	Lineseparator, usually '\n' or '\r\n'
+	 * @return Result
+	 */
+	public static List<String> csvToListString(final String csvString, final String seperator, final String lineSeperator) {
+		List<String> result = new ArrayList<String>();
+		String[] lines = csvString.split(lineSeperator);
+		for (final String line : lines) {
+			String[] values = line.split(seperator);
+			String resultValue = null;
+			for (final String str : values) {
+				resultValue = StringUtil.safeTrimWithReplace(str);
+				if (!resultValue.isEmpty()) {
+					result.add(resultValue);
+				}
+			}
+		}
+		return result;
+	}
+}
diff --git a/src/main/java/de/tvo/tools/ConvertUtil.java b/src/main/java/de/tvo/tools/ConvertUtil.java
new file mode 100644
index 0000000..2e063bd
--- /dev/null
+++ b/src/main/java/de/tvo/tools/ConvertUtil.java
@@ -0,0 +1,14 @@
+package de.tvo.tools;
+
+public class ConvertUtil {
+
+	public ConvertUtil() {
+		// TODO Auto-generated constructor stub
+	}
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/src/main/java/de/tvo/tools/CryptoUtil.java b/src/main/java/de/tvo/tools/CryptoUtil.java
new file mode 100644
index 0000000..7a5cb43
--- /dev/null
+++ b/src/main/java/de/tvo/tools/CryptoUtil.java
@@ -0,0 +1,71 @@
+package de.tvo.tools;
+
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+/**
+ * Crypto Zeugs
+ * @author KirchnerM, Huellmante
+ *
+ */
+public class CryptoUtil {
+
+	/**
+	 * Hash with Geis Salt
+	 * @param password password to Hash
+	 * @return HASH
+	 */
+	public static final String getGeisSalt(final String password) {
+		return hashIt(password, "GP17", "SHA-256");
+	}
+	
+	/**
+	 * Hashes String + String to HASH
+	 * @param pw String
+	 * @param salt String
+	 * @param algorithm Algo z. B. SHA-256
+	 * @return HASH
+	 */
+	public final static String hashIt(final String pw, final String salt, final String algorithm) {
+		String pwsalt = pw+salt;
+		return hashIt(pwsalt, algorithm);
+	}
+	
+	/**
+	 * Hashes String + String to HASH
+	 * @param pw String
+	 * @param algorithm Algo z. B. SHA-256
+	 * @return HASH
+	 */
+	public final static String hashIt(final String pw, final String algorithm) {
+		try {
+			final MessageDigest md = MessageDigest.getInstance(algorithm); //SHA-1 oder SHA-256
+			md.update(pw.getBytes());
+			return bytesToHex(md.digest());
+		} catch (NoSuchAlgorithmException e) {
+			e.printStackTrace();
+			return "";
+		}
+	}
+	
+	/**
+	 * Digits
+	 */
+	private final static char[] hexArray = new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
+
+	/**
+	 * 
+	 * @param bytes
+	 * @return
+	 */
+	public final static String bytesToHex(final byte[] bytes) {
+		final char[] hexChars = new char[bytes.length * 2];
+		for (int j = 0; j < bytes.length; ++j) {
+			final int v = bytes[j] & 0xFF;
+			hexChars[j * 2] = hexArray[v >>> 4];
+			hexChars[j * 2 + 1] = hexArray[v & 0x0F];
+		}
+		return new String(hexChars);
+	}
+	
+}
diff --git a/src/main/java/de/tvo/tools/DateFromTo.java b/src/main/java/de/tvo/tools/DateFromTo.java
new file mode 100644
index 0000000..076c1dd
--- /dev/null
+++ b/src/main/java/de/tvo/tools/DateFromTo.java
@@ -0,0 +1,20 @@
+package de.tvo.tools;
+
+import java.util.Date;
+
+public class DateFromTo {
+	
+	private Date m_dateFrom = null;
+	public Date getDateFrom() { return m_dateFrom; }
+	
+	private Date m_dateTo = null;
+	public Date getDateTo() { return m_dateTo; }
+	
+	public DateFromTo(Date dateFrom, Date dateTo) {
+		this.m_dateFrom = dateFrom;
+		this.m_dateTo = dateTo;
+	}
+	
+	
+
+}
diff --git a/src/main/java/de/tvo/tools/DateUtil.java b/src/main/java/de/tvo/tools/DateUtil.java
new file mode 100644
index 0000000..64bf679
--- /dev/null
+++ b/src/main/java/de/tvo/tools/DateUtil.java
@@ -0,0 +1,1241 @@
+package de.tvo.tools;
+
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.concurrent.TimeUnit;
+
+public class DateUtil {
+
+	private static SimpleDateFormat dbdateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
+	private static boolean DEBUG = false;
+	
+	public DateUtil() {
+
+	}
+
+	public static void main(String[] args) {
+		System.out.println(getDateFromDaysSinceJesus(737661));
+		System.out.println(getDaysSinceJesus(new Date()));
+	}
+	
+	public static Date parseDate(String datum, String pattern) {
+		//if (pattern.equals("yyyy-MM-dd") && datum.equals("0000-00-00")) return null;
+		SimpleDateFormat format = new SimpleDateFormat( pattern );
+		try {
+			return format.parse( datum );
+		} catch (ParseException e) {
+		}
+		return null;
+	}
+	
+	public static String formatDate(Date datum, String pattern) {
+	    try {
+	      return new SimpleDateFormat(pattern).format(datum);
+	    } catch (Exception e) {
+	    	
+	    }
+	    return null;
+	}
+	
+	/**
+	 * Get Timestamp from Date with format: yyyyMMddHHmmss
+	 * 
+	 * @return Long Date yyyyMMddHHmmss
+	 */
+	public static long getTimestampFormatedLong() {
+		return Long.parseLong(getTimestamp(new Date()));
+	}
+	
+	/**
+	 * Get Timestamp from Date with format: yyyyMMddHHmmss
+	 * 
+	 * @param datum
+	 * @return Long Date yyyyMMddHHmmss
+	 */
+	public static long getTimestampFormatedLong(Date date) {
+		return Long.parseLong(getTimestamp(date));
+	}
+	
+	/**
+	 * Get the Long from Date
+	 * 
+	 * @param date Date to get the Long from
+	 * @return LongVariable of the given Date
+	 */
+	public static long getLongFromDate(Date date) {
+		
+		return date.getTime();
+		
+	}
+	
+	/**
+	 * Get Timestamp from Date with format: yyyyMMddHHmmss
+	 * 
+	 * @param datum
+	 * @return String Date yyyyMMddHHmmss
+	 */
+	public static String getTimestamp(Date datum) {
+		String result = null;
+		
+		result = dbdateFormat.format(datum);
+		
+		return result;
+	}
+
+	/**
+	 * Returns the day-difference of two dates in String
+	 *  
+	 * @param dateFrom Starting Date
+	 * @param dateTo End Date
+	 * @param format format of the dates
+	 * @return 
+	 */
+	public static String dateDayDiffString(String dateFrom, String dateTo, String format) {
+		return Long.toString(dateDayDiffLong(dateFrom, dateTo, format));
+	}
+	
+	/**
+	 * Returns the day-difference of two dates in String using yyyyMMdd as format
+	 *  
+	 * @param dateFrom Starting Date
+	 * @param dateTo End Date
+	 * @return 
+	 */
+	public static String dateDayDiffString(String dateFrom, String dateTo) {
+		return dateDayDiffString(dateFrom, dateTo, "yyyyMMdd");
+	}
+
+	/**
+	 * Returns the day-difference of two dates in long
+	 * 
+	 * @param dateFrom Starting Date
+	 * @param dateTo End Date
+	 * @param format format of the dates
+	 * @return 
+	 */
+	public static long dateDayDiffLong(String dateFrom, String dateTo, String format) {
+		return (long)Math.floor(dateDayDiffDouble(dateFrom, dateTo, format));
+	}
+	
+	/**
+	 * Returns the day-difference of two dates in double
+	 * 
+	 * @param dateFrom Starting Date
+	 * @param dateTo End Date
+	 * @param format format of the dates
+	 * @return 
+	 */
+	public static double dateDayDiffDouble(String dateFrom, String dateTo, String format) {
+		SimpleDateFormat formatter = new SimpleDateFormat(format); 
+		GregorianCalendar calFrom = new GregorianCalendar();
+		GregorianCalendar calTo = new GregorianCalendar();
+		try {
+			calFrom.setTime(formatter.parse(dateFrom));
+			calTo.setTime(formatter.parse(dateTo));
+		} catch (ParseException e) {
+			e.printStackTrace();
+			return 0L;
+		}
+		if (DEBUG){
+			System.out.println("Difference in day : " + Long.toString((calTo.getTimeInMillis() - calFrom.getTimeInMillis())/86400000));
+		}
+		return (calTo.getTimeInMillis() - calFrom.getTimeInMillis())/86400000D;
+	}
+	
+
+	/**
+	 * Returns the day-difference of two dates in Long using yyyyMMdd as format
+	 * 
+	 * @param dateFrom Starting Date
+	 * @param dateTo End Date
+	 * @return 
+	 */
+	public static long dateDayDiffLong(String dateFrom, String dateTo) {
+		return dateDayDiffLong(dateFrom, dateTo, "yyyyMMdd");
+	}
+	
+	/**
+	 * Returns Calendar (Gregorian Calendar to be exact) of given Date and Time 
+	 * 
+	 * @param aDate Date to be used in Calendar
+	 * @param aTime Time to be used in Calendar
+	 * @param format of aDate+aTime (!)
+	 * @return Calendar (Gregorian Calendar to be exact) of given Date and Time
+	 */
+	public static Calendar getCalendatfromDateTimeString(String aDate, String aTime, String format) {
+		SimpleDateFormat formatter = new SimpleDateFormat(format); 
+		GregorianCalendar cal = new GregorianCalendar();
+		try {
+			cal.setTime(formatter.parse(aDate+aTime));
+		} catch (ParseException e1) {
+			// TODO Auto-generated catch block
+			e1.printStackTrace();
+		}
+		return cal;
+	}
+	
+	/**
+	 * Returns Calendar (Gregorian Calendar to be exact) of given Date and Time with format yyyyMMddhhmmss
+	 * 
+	 * @param aDate Date to be used in Calendar
+	 * @param aTime Time to be used in Calendar
+	 * @return Calendar (Gregorian Calendar to be exact) of given Date and Time
+	 */
+	public static Calendar getCalendatfromDateTimeString(String aDate, String aTime) {
+		return getCalendatfromDateTimeString(aDate, aTime,"yyyyMMddhhmmss");
+	}
+
+	public static String getDateTimeDiff(Calendar vonTime, Calendar bisTime,boolean csvAusgabe) {
+		// TODO Auto-generated method stub
+		StringBuffer ausgabeBuffer = new StringBuffer();
+		String timeDiff = null;
+		long tmpWert = 0;
+		long vonCalMilli = 0;
+		long bisCalMilli = 0;
+		long diffCallMilli = 0;
+
+		vonCalMilli = vonTime.getTimeInMillis();
+		bisCalMilli = bisTime.getTimeInMillis();
+
+		diffCallMilli = bisCalMilli - vonCalMilli;
+
+		long day = diffCallMilli / 86400000;
+
+		if (DEBUG)
+			System.out.println("Tage: " + day);
+
+		tmpWert = diffCallMilli - (day * 86400000);
+		long hour = tmpWert / 3600000;
+
+		if (DEBUG)
+			System.out.println("Stunden: " + hour);
+
+		tmpWert = tmpWert - (hour * 3600000);
+		long min = tmpWert / 60000;
+
+		if (DEBUG)
+			System.out.println("Minuten: " + min);
+
+		if (csvAusgabe) {
+			timeDiff = day + ";" + hour + ";" + min;
+		} else {
+
+			if (day >= 1)
+				ausgabeBuffer.append(day + " Tage ");
+			ausgabeBuffer.append(hour + " Std. " + min + " Min.");
+
+			timeDiff = ausgabeBuffer.toString();
+
+			// timeDiff = day + " Tage " + hour + " Std. " + min + " Min.";
+
+			if (DEBUG)
+				System.out.println("Ausgabe Diff.: " + timeDiff);
+		}
+
+		return timeDiff;
+	}
+
+	/**
+	 * 
+	 * @param vonTime
+	 * @param bisTime
+	 * @param csvAusgabe
+	 * @return
+	 */
+	public static String getDateTimeDiff(Date vonTime, Date bisTime,
+			boolean csvAusgabe) {
+		StringBuffer ausgabeBuffer = new StringBuffer();
+		String timeDiff = null;
+		long tmpWert = 0;
+		long diffCallMilli = 0;
+		String secString = null;
+
+		diffCallMilli = bisTime.getTime() - vonTime.getTime();
+
+		long day = diffCallMilli / 86400000;
+
+		if (DEBUG)
+			System.out.println("Tage: " + day);
+		tmpWert = diffCallMilli - (day * 86400000);
+		if (DEBUG)
+			System.out.println("Hour: " + tmpWert);
+		long hour = tmpWert / 3600000;
+
+		if (DEBUG)
+			System.out.println("Stunden: " + hour);
+
+		tmpWert = tmpWert - (hour * 3600000);
+		if (DEBUG)
+			System.out.println("Min: " + tmpWert);
+		long min = tmpWert / 60000;
+
+		if (DEBUG)
+			System.out.println("Minuten: " + min);
+
+		tmpWert = tmpWert - (min * 60000);
+		if (DEBUG)
+			System.out.println("Sec: " + tmpWert);
+		long sec = tmpWert / 1000;
+
+		secString = "" + sec;
+
+		if (DEBUG)
+			System.out.println("Sekunden: " + sec);
+
+		if (secString.length() > 2) {
+			secString = secString.substring(0, 2);
+		}
+
+		if (csvAusgabe) {
+			timeDiff = day + ";" + hour + ";" + min + ";" + secString;
+		} else {
+
+			if (day >= 1)
+				ausgabeBuffer.append(day + " Tage ");
+			ausgabeBuffer.append(hour + " Std. " + min + " Min. " + secString
+					+ " Sec");
+
+			timeDiff = ausgabeBuffer.toString();
+
+			// timeDiff = day + " Tage " + hour + " Std. " + min + " Min.";
+
+			if (DEBUG)
+				System.out.println("Ausgabe Diff.: " + timeDiff);
+		}
+
+		return timeDiff;
+	}
+
+	// set Datum und 2 halb 4 fuer viertel Jaehrlich zurueck Datum von bis
+	public static int[] getDatumVonBisQuatalGEHTNET(String datumAktuell,
+			int halbViertelJaehrlich) {
+		// TODO Auto-generated method stub
+		int[] datumVonBis = new int[3];
+		String[] datumVonBisString = new String[3];
+		String jahrString = null;
+		String monatTag = null;
+		int monatTagZahl = 0;
+
+		if (DEBUG)
+			System.out.println(datumAktuell);
+
+		if (datumAktuell.trim().length() == 8) {
+			jahrString = datumAktuell.substring(0, 4);
+			monatTag = datumAktuell.substring(4, 8);
+			monatTagZahl = Integer.parseInt(monatTag);
+
+		} else {
+			// InfoDialog("Datum muss 8 Stellen haben!");
+		}
+
+		int[][] arrayDatumHalbJaehrlich = new int[2][3];
+		int[][] arrayDatumViertelJaehrlich = new int[4][3];
+
+		/* HalbJaehrlich */
+		// erstes HalbJahr
+		arrayDatumHalbJaehrlich[0][0] = 1;
+		arrayDatumHalbJaehrlich[0][1] = 101;
+		arrayDatumHalbJaehrlich[0][2] = 630;
+		// zweites HalbJar
+		arrayDatumHalbJaehrlich[1][0] = 2;
+		arrayDatumHalbJaehrlich[1][1] = 701;
+		arrayDatumHalbJaehrlich[1][2] = 1231;
+
+		/* ViertelJaehrlich */
+		// erstes ViertelJahr
+		arrayDatumViertelJaehrlich[0][0] = 1;
+		arrayDatumViertelJaehrlich[0][1] = 101;
+		arrayDatumViertelJaehrlich[0][2] = 331;
+
+		// zweites ViertelJahr
+		arrayDatumViertelJaehrlich[1][0] = 2;
+		arrayDatumViertelJaehrlich[1][1] = 401;
+		arrayDatumViertelJaehrlich[1][2] = 630;
+
+		// drittes ViertelJahr
+		arrayDatumViertelJaehrlich[2][0] = 3;
+		arrayDatumViertelJaehrlich[2][1] = 701;
+		arrayDatumViertelJaehrlich[2][2] = 930;
+
+		// viertes ViertelJahr
+		arrayDatumViertelJaehrlich[3][0] = 4;
+		arrayDatumViertelJaehrlich[3][1] = 1001;
+		arrayDatumViertelJaehrlich[3][2] = 1231;
+
+		if (halbViertelJaehrlich == 2) {
+			for (int quartal = 0; quartal < arrayDatumHalbJaehrlich.length; ++quartal) {
+				if (monatTagZahl >= arrayDatumHalbJaehrlich[quartal][1]
+						&& monatTagZahl <= arrayDatumHalbJaehrlich[quartal][2]) {
+					datumVonBisString[0] = ""
+							+ arrayDatumHalbJaehrlich[quartal][0];
+					String vonMonatTag = ""
+							+ arrayDatumHalbJaehrlich[quartal][1];
+					String bisMonatTag = ""
+							+ arrayDatumHalbJaehrlich[quartal][2];
+					datumVonBisString[1] = jahrString
+							+ StringUtil.fillString(vonMonatTag, 4, "0", "links");
+					datumVonBisString[2] = jahrString
+							+ StringUtil.fillString(bisMonatTag, 4, "0", "links");
+
+				}
+			}
+		}
+
+		if (halbViertelJaehrlich == 4) {
+			for (int quartal = 0; quartal < arrayDatumViertelJaehrlich.length; ++quartal) {
+				if (monatTagZahl >= arrayDatumViertelJaehrlich[quartal][1]
+						&& monatTagZahl <= arrayDatumViertelJaehrlich[quartal][2]) {
+					datumVonBisString[0] = ""
+							+ arrayDatumViertelJaehrlich[quartal][0];
+					String vonMonatTag = ""
+							+ arrayDatumViertelJaehrlich[quartal][1];
+					String bisMonatTag = ""
+							+ arrayDatumViertelJaehrlich[quartal][2];
+					datumVonBisString[1] = jahrString
+							+ StringUtil.fillString(vonMonatTag, 4, "0", "links");
+					datumVonBisString[2] = jahrString
+							+ StringUtil.fillString(bisMonatTag, 4, "0", "links");
+				}
+			}
+		}
+
+		for (int quartal = 0; quartal < datumVonBisString.length; ++quartal) {
+			datumVonBis[quartal] = Integer.parseInt(datumVonBisString[quartal]);
+		}
+
+		return datumVonBis;
+	}
+
+	// set Datum und 2 halb 4 fuer viertel Jaehrlich zurueck Datum von bis
+	// TENOVIS
+	public static int[] getDatumVonBisQuatalTEN(String datumAktuell,
+			int halbViertelJaehrlich) {
+		// TODO Auto-generated method stub
+		int[] datumVonBis = new int[3];
+		String[] datumVonBisString = new String[3];
+		String jahrString = "";
+		int jahrInt = 0;
+		String monatTag = null;
+		int monatTagZahl = 0;
+		int aktuellDatum = 0;
+
+		if (DEBUG)
+			System.out.println(datumAktuell);
+		System.out.println(datumAktuell);
+
+		if (datumAktuell.trim().length() == 8) {
+			jahrString = datumAktuell.substring(0, 4);
+			monatTag = datumAktuell.substring(4, 8);
+
+			try {
+				monatTagZahl = Integer.parseInt(monatTag);
+				jahrInt = Integer.parseInt(jahrString);
+				// System.out.println(jahrInt);
+				aktuellDatum = Integer.parseInt(datumAktuell);
+			} catch (Exception e) {
+				// TODO: handle exception
+				e.printStackTrace();
+			}
+
+		} else {
+			// InfoDialog("Datum muss 8 Stellen haben!");
+			return null;
+		}
+
+		if (halbViertelJaehrlich == 1) {
+			try {
+
+				int[][] arrayDatumJaehrlichMonatTag = new int[1][3]; // Jahr //
+																		// OK
+				int[][] arrayDatumJaehrlichJahrPlusMinus = new int[1][3]; // Jahr
+																			// //
+																			// OK
+				int[][] arrayDatumJaehrlich = new int[1][3]; // Jahr
+				String[][] arrayDatumJaehrlichString = new String[1][3]; // Jahr
+				int[][] arrayDatumJaehrlichJahr = new int[1][3]; // Jahr
+
+				/* Jaehrlich */
+				// Jahr
+				// setze Datum von bis
+				arrayDatumJaehrlichMonatTag[0][0] = 1;
+				arrayDatumJaehrlichMonatTag[0][1] = 1001; // 01.10 (07)
+				arrayDatumJaehrlichMonatTag[0][2] = 930; // 30.09 (08)
+
+				// setze Jahr von bis
+				arrayDatumJaehrlichJahrPlusMinus[0][0] = 1;
+				if (monatTagZahl >= arrayDatumJaehrlichMonatTag[0][1]) {
+					arrayDatumJaehrlichJahrPlusMinus[0][1] = 0;
+					arrayDatumJaehrlichJahrPlusMinus[0][2] = 1;
+				} else {
+					arrayDatumJaehrlichJahrPlusMinus[0][1] = -1;
+					arrayDatumJaehrlichJahrPlusMinus[0][2] = 0;
+				}
+				arrayDatumJaehrlichJahr[0][0] = 1;
+				arrayDatumJaehrlichJahr[0][1] = jahrInt
+						+ arrayDatumJaehrlichJahrPlusMinus[0][1];
+				arrayDatumJaehrlichJahr[0][2] = jahrInt
+						+ arrayDatumJaehrlichJahrPlusMinus[0][2];
+
+				arrayDatumJaehrlichString[0][0] = "1";
+				arrayDatumJaehrlichString[0][1] = ""
+						+ arrayDatumJaehrlichJahr[0][1]
+						+ StringUtil.fillString("" + arrayDatumJaehrlichMonatTag[0][1],
+								4, "0", "links");
+				arrayDatumJaehrlichString[0][2] = ""
+						+ arrayDatumJaehrlichJahr[0][2]
+						+ StringUtil.fillString("" + arrayDatumJaehrlichMonatTag[0][2],
+								4, "0", "links");
+
+				for (int pos = 0; pos < arrayDatumJaehrlichString.length; pos++) {
+					for (int xpos = 0; xpos < arrayDatumJaehrlichString[pos].length; xpos++) {
+						arrayDatumJaehrlich[pos][xpos] = Integer
+								.parseInt(arrayDatumJaehrlichString[pos][xpos]);
+					}
+				}
+
+				datumVonBisString[0] = "" + arrayDatumJaehrlich[0][0];
+				String vonMonatTag = "" + arrayDatumJaehrlich[0][1];
+				String bisMonatTag = "" + arrayDatumJaehrlich[0][2];
+
+				datumVonBisString[1] = vonMonatTag;
+				datumVonBisString[2] = bisMonatTag;
+
+			} catch (Exception e) {
+				// TODO: handle exception
+				// Fehler Jaehrlich
+				e.printStackTrace();
+			}
+
+		} else if (halbViertelJaehrlich == 2) {
+			try {
+				int[][] arrayDatumHalbJaehrlichMonatTag = new int[2][3]; // halbJahr
+																			// //
+																			// OK
+				int[][] arrayDatumHalbJaehrlichJahrPlusMinus = new int[2][3]; // halb
+																				// Jahr
+																				// //
+																				// OK
+				int[][] arrayDatumHalbJaehrlich = new int[2][3]; // halb Jahr
+				String[][] arrayDatumHalbJaehrlichString = new String[2][3]; // halb
+																				// Jahr
+				int[][] arrayDatumHalbJaehrlichJahr = new int[2][3]; // halb
+																		// Jahr
+
+				/* HalbJaehrlich */
+				// erstes HalbJahr
+				arrayDatumHalbJaehrlichMonatTag[0][0] = 1;
+				arrayDatumHalbJaehrlichMonatTag[0][1] = 1001; // 01.10
+				arrayDatumHalbJaehrlichMonatTag[0][2] = 331; // 31.03
+				// zweites HalbJahr
+				arrayDatumHalbJaehrlichMonatTag[1][0] = 2;
+				arrayDatumHalbJaehrlichMonatTag[1][1] = 401; // 01.04
+				arrayDatumHalbJaehrlichMonatTag[1][2] = 930; // 30.09
+
+				if (monatTagZahl >= arrayDatumHalbJaehrlichMonatTag[0][1]) {
+					arrayDatumHalbJaehrlichJahrPlusMinus[0][0] = 1;
+					arrayDatumHalbJaehrlichJahrPlusMinus[0][1] = 0;
+					arrayDatumHalbJaehrlichJahrPlusMinus[0][2] = 1;
+				} else {
+					arrayDatumHalbJaehrlichJahrPlusMinus[0][0] = 2;
+					arrayDatumHalbJaehrlichJahrPlusMinus[0][1] = -1;
+					arrayDatumHalbJaehrlichJahrPlusMinus[0][2] = 0;
+				}
+
+				arrayDatumHalbJaehrlichJahr[0][0] = 1;
+				arrayDatumHalbJaehrlichJahr[0][1] = jahrInt
+						+ arrayDatumHalbJaehrlichJahrPlusMinus[0][1];
+				arrayDatumHalbJaehrlichJahr[0][2] = jahrInt
+						+ arrayDatumHalbJaehrlichJahrPlusMinus[0][2];
+				// zweites HalbJar
+				arrayDatumHalbJaehrlichJahr[1][0] = 2;
+				arrayDatumHalbJaehrlichJahr[1][1] = jahrInt
+						+ arrayDatumHalbJaehrlichJahrPlusMinus[1][1];
+				arrayDatumHalbJaehrlichJahr[1][2] = jahrInt
+						+ arrayDatumHalbJaehrlichJahrPlusMinus[1][2];
+
+				arrayDatumHalbJaehrlichString[0][0] = "1";
+				arrayDatumHalbJaehrlichString[0][1] = ""
+						+ arrayDatumHalbJaehrlichJahr[0][1]
+						+ StringUtil.fillString(""
+								+ arrayDatumHalbJaehrlichMonatTag[0][1], 4,
+								"0", "links");
+				arrayDatumHalbJaehrlichString[0][2] = ""
+						+ arrayDatumHalbJaehrlichJahr[0][2]
+						+ StringUtil.fillString(""
+								+ arrayDatumHalbJaehrlichMonatTag[0][2], 4,
+								"0", "links");
+
+				arrayDatumHalbJaehrlichString[1][0] = "2";
+				arrayDatumHalbJaehrlichString[1][1] = ""
+						+ arrayDatumHalbJaehrlichJahr[1][1]
+						+ StringUtil.fillString(""
+								+ arrayDatumHalbJaehrlichMonatTag[1][1], 4,
+								"0", "links");
+				arrayDatumHalbJaehrlichString[1][2] = ""
+						+ arrayDatumHalbJaehrlichJahr[1][2]
+						+ StringUtil.fillString(""
+								+ arrayDatumHalbJaehrlichMonatTag[1][2], 4,
+								"0", "links");
+
+				for (int pos = 0; pos < arrayDatumHalbJaehrlichString.length; pos++) {
+					for (int xpos = 0; xpos < arrayDatumHalbJaehrlichString[pos].length; xpos++) {
+						System.err
+								.println(arrayDatumHalbJaehrlichString[pos][xpos]);
+						arrayDatumHalbJaehrlich[pos][xpos] = Integer
+								.parseInt(arrayDatumHalbJaehrlichString[pos][xpos]);
+					}
+				}
+
+				for (int quartal = 0; quartal < arrayDatumHalbJaehrlich.length; ++quartal) {
+					if (aktuellDatum >= arrayDatumHalbJaehrlich[quartal][1]
+							&& aktuellDatum <= arrayDatumHalbJaehrlich[quartal][2]) {
+						datumVonBisString[0] = ""
+								+ arrayDatumHalbJaehrlich[quartal][0];
+						String vonMonatTag = ""
+								+ arrayDatumHalbJaehrlich[quartal][1];
+						String bisMonatTag = ""
+								+ arrayDatumHalbJaehrlich[quartal][2];
+
+						System.out.println("vonMonatTag: " + vonMonatTag);
+						System.out.println("bisMonatTag: " + bisMonatTag);
+
+						datumVonBisString[1] = vonMonatTag;
+						datumVonBisString[2] = bisMonatTag;
+					}
+				}
+
+			} catch (Exception e) {
+				// TODO: handle exception
+				// Fehler halbJaehrlich
+
+				e.printStackTrace();
+			}
+
+		} else if (halbViertelJaehrlich == 4) {
+			try {
+				int[][] arrayDatumViertelJaehrlich = new int[4][3]; // viertel
+																	// Jahr
+
+				/* ViertelJaehrlich */
+				// erstes ViertelJahr
+				arrayDatumViertelJaehrlich[0][0] = 1;
+				arrayDatumViertelJaehrlich[0][1] = 101;
+				arrayDatumViertelJaehrlich[0][2] = 331;
+
+				// zweites ViertelJahr
+				arrayDatumViertelJaehrlich[1][0] = 2;
+				arrayDatumViertelJaehrlich[1][1] = 401;
+				arrayDatumViertelJaehrlich[1][2] = 630;
+
+				// drittes ViertelJahr
+				arrayDatumViertelJaehrlich[2][0] = 3;
+				arrayDatumViertelJaehrlich[2][1] = 701;
+				arrayDatumViertelJaehrlich[2][2] = 930;
+
+				// viertes ViertelJahr
+				arrayDatumViertelJaehrlich[3][0] = 4;
+				arrayDatumViertelJaehrlich[3][1] = 1001;
+				arrayDatumViertelJaehrlich[3][2] = 1231;
+
+				for (int quartal = 0; quartal < arrayDatumViertelJaehrlich.length; ++quartal) {
+					if (monatTagZahl >= arrayDatumViertelJaehrlich[quartal][1]
+							&& monatTagZahl <= arrayDatumViertelJaehrlich[quartal][2]) {
+						datumVonBisString[0] = ""
+								+ arrayDatumViertelJaehrlich[quartal][0];
+						String vonMonatTag = ""
+								+ arrayDatumViertelJaehrlich[quartal][1];
+						String bisMonatTag = ""
+								+ arrayDatumViertelJaehrlich[quartal][2];
+						datumVonBisString[1] = jahrString
+								+ StringUtil.fillString(vonMonatTag, 4, "0", "links");
+						datumVonBisString[2] = jahrString
+								+ StringUtil.fillString(bisMonatTag, 4, "0", "links");
+					}
+				}
+
+			} catch (Exception e) {
+				// TODO: handle exception
+				// Fehler viertel Jaehrlich
+				e.printStackTrace();
+			}
+
+		} else {
+			return null;
+		}
+
+		for (int quartal = 0; quartal < datumVonBisString.length; ++quartal) {
+			System.out.println(datumVonBisString[quartal]);
+			datumVonBis[quartal] = Integer.parseInt(datumVonBisString[quartal]);
+		}
+
+		return datumVonBis;
+	}
+	
+    /**
+     * 
+     * DE: Gibt die Differenz zwischen zwei Dates in Calendar.HOUR,
+     * Calendar.MINUTE oder Calendar.SECOND zurueck.
+     * 
+     * EN:
+     * 
+     * @param vonDate
+     * @param bisDate
+     * @param second_minute_hour
+     * @return
+     */
+    public static Float getDateDiff(Date vonDate, Date bisDate, int second_minute_hour) {
+	float result = 0;
+
+	try {
+	    Calendar vonCalendar = GregorianCalendar.getInstance();
+	    Calendar bisCalendar = GregorianCalendar.getInstance();
+
+	    vonCalendar.setTime(vonDate);
+	    bisCalendar.setTime(bisDate);
+
+	    result = Float.valueOf(bisCalendar.getTimeInMillis() - vonCalendar.getTimeInMillis());
+
+	    //System.out.println("Millisec: " + result);
+
+	    switch (second_minute_hour) {
+	    case Calendar.HOUR:
+		result = result / 3600000;
+		break;
+
+	    case Calendar.MINUTE:
+		result = result / 60000;
+		break;
+
+	    case Calendar.SECOND:
+		result = result / 1000;
+		break;
+
+	    default:
+		// Milli Secound
+
+		break;
+	    }
+
+	} catch (Exception e) {
+	    e.printStackTrace();
+	}
+	return result;
+    }
+    
+    
+    public static long getDateLongFromString(String date, String time ,String format) {
+		Calendar cal_1 = new GregorianCalendar();
+		SimpleDateFormat formatter = new SimpleDateFormat(format);
+		try {
+			cal_1.setTime(formatter.parse(date+time));
+		} catch (ParseException e) {
+			e.printStackTrace();
+		}
+
+		return cal_1.getTimeInMillis();
+	}
+    
+    
+    public static String getDateStringFromDateFormat(Date date,
+			String format) {
+		return new SimpleDateFormat(format).format(date);
+	}
+	
+	public static long getDateLongFromString(String datumYYYYMMDD) {
+	        return getDateLongFromString(datumYYYYMMDD,"","yyyyMMdd");
+	        
+	}
+	
+	public static long getDateLongFromString(String datumYYYYMMDD, String zeitHHmmss) {
+		String as = null;
+		Calendar cal_1 = new GregorianCalendar();
+		
+		as = datumYYYYMMDD;
+	      if (DEBUG == true) System.out.println("Datum von: " +as);
+	        String vdateJahrS = new String(as.substring(0,4));
+	        String vdateMonatS = new String(as.substring(4,6));
+	        String vdateTagS = new String(as.substring(6,8));
+	        
+	        as = zeitHHmmss;
+		    if (DEBUG == true) System.out.println("Datum von: " +as);
+		    String stundeS = new String(as.substring(0,2));
+		    String minuteS = new String(as.substring(2,4));
+		    String sekundeS = new String(as.substring(4,6));
+	        
+	                  
+	        int vdateJahr = Integer.parseInt(vdateJahrS);
+	        int vdateMonat = Integer.parseInt(vdateMonatS);
+	        int vdateTag = Integer.parseInt(vdateTagS);
+		
+	        int stunde = Integer.parseInt(stundeS);
+	        int minute = Integer.parseInt(minuteS);
+	        int sekunde = Integer.parseInt(sekundeS);
+		
+	        
+	        
+	        cal_1.set( vdateJahr, vdateMonat -1, vdateTag, stunde, minute, sekunde );                      // erster Zeitpunkt
+	        
+	        
+	        return cal_1.getTimeInMillis();
+	        
+	}
+	
+	public static Date getDateFromString(String datum_yyyyMMddHHmmss) {
+		
+		if (datum_yyyyMMddHHmmss != null && datum_yyyyMMddHHmmss.trim().length() == 14) {
+			 return getDateFromString(datum_yyyyMMddHHmmss.substring(0, 8), datum_yyyyMMddHHmmss.substring(8)); 
+		} 
+		return null;
+	}
+	
+	public static Date getDateFromString(String datumYYYYMMDD, String zeitHHmmss) {
+		String as = null;
+		Calendar cal_1 = new GregorianCalendar();
+		
+		as = datumYYYYMMDD;
+	      if (DEBUG == true) System.out.println("Datum von: " +as);
+	        String vdateJahrS = new String(as.substring(0,4));
+	        String vdateMonatS = new String(as.substring(4,6));
+	        String vdateTagS = new String(as.substring(6,8));
+	        
+	        as = zeitHHmmss;
+		    if (DEBUG == true) System.out.println("Datum von: " +as);
+		    String stundeS = new String(as.substring(0,2));
+		    String minuteS = new String(as.substring(2,4));
+		    String sekundeS = new String(as.substring(4,6));
+	        
+	                  
+	        int vdateJahr = Integer.parseInt(vdateJahrS);
+	        int vdateMonat = Integer.parseInt(vdateMonatS);
+	        int vdateTag = Integer.parseInt(vdateTagS);
+		
+	        int stunde = Integer.parseInt(stundeS);
+	        int minute = Integer.parseInt(minuteS);
+	        int sekunde = Integer.parseInt(sekundeS);
+		
+	        
+	        
+	        cal_1.set( vdateJahr, vdateMonat -1, vdateTag, stunde, minute, sekunde );                      // erster Zeitpunkt
+	        
+	        
+	        return new Date(cal_1.getTimeInMillis());
+	        
+	}
+	
+	public static Long getTimestampLong(Date datum) {
+		return Long.parseLong(getTimestamp(datum));
+	}
+	
+	
+	/**
+	 * Es kann zu dem uebergebenen Datum Tage, Stunden oder Minuten dazu gerechnet werden.
+	 * 
+	 * @param dateAktuell
+	 * @param diffDays
+	 * @param calendaType DATE HOUR MINUTE
+	 * @return
+	 */
+	public static Date getDatePlusDateHourMinute(Date dateAktuell, int diffDays, int calendarType) {
+		Date endDate = null;
+		Calendar c = Calendar.getInstance();
+		c.setTime(dateAktuell); // Now use today date.
+		c.add(calendarType, diffDays); // Adding 5 days
+		endDate = c.getTime();
+		
+		return endDate;
+	}
+	
+	/**
+	 * Es kann zu dem uebergebenen Datum Tage, Stunden oder Minuten dazu gerechnet werden.
+	 * 
+	 * @param dateAktuell
+	 * @param diffDays
+	 * @param calendaType DATE HOUR MINUTE
+	 * @return
+	 */
+	public static Date getDateMinusDateHourMinute(Date dateAktuell, int diffDays, int calendarType) {
+		Date endDate = null;
+		Calendar c = Calendar.getInstance();
+		c.setTime(dateAktuell); // Now use today date.
+		c.add(calendarType, -diffDays); // Adding 5 days
+		endDate = c.getTime();
+		
+		return endDate;
+	}
+
+	
+
+	/**
+	 * Ermittelt den vorherigen Arbeitstag (Gestern ohne Wochenende)
+	 * @param inputDay Tag
+	 * @return Arbeitstag danach
+	 */
+	public static Date getWeekdayBeforeDay(Date inputDay) {
+		Date day = new Date( inputDay.getTime() );
+		GregorianCalendar cal = new GregorianCalendar();
+		day.setTime( day.getTime() - (3600000*24) );
+		cal.setTime( day );
+		
+		while ( cal.get( Calendar.DAY_OF_WEEK ) == Calendar.SATURDAY || cal.get( Calendar.DAY_OF_WEEK ) == Calendar.SUNDAY ) {
+			day.setTime( day.getTime() - (3600000*24) );
+			cal.setTime( day );
+		}
+		
+		return day;
+	}
+	
+	
+	
+	/**
+	 * Ermittelt den nächsten Arbeitstag
+	 * @param inputDay Tag
+	 * @return Arbeitstag danach
+	 */
+	public static Date getWeekdayAfterDay(Date inputDay) {
+		Date day = new Date( inputDay.getTime() );
+		GregorianCalendar cal = new GregorianCalendar();
+		day.setTime( day.getTime() + (3600000*24) );
+		cal.setTime( day );
+		
+		while ( cal.get( Calendar.DAY_OF_WEEK ) == 1 || cal.get( Calendar.DAY_OF_WEEK ) == 7 ) {
+			day.setTime( day.getTime() + (3600000*24) );
+			cal.setTime( day );
+		}
+		
+		return day;
+	}
+	
+	/**
+	 * Prüft ob der übergebene Tag ein Tag nach einem Feiertag an dem betreffenden Standort ist
+	 * @param datum Datum welches geprüft wird
+	 * @param firma Fira
+	 * @param ndl Niederlassung
+	 * @return Ob der übergebene Tag ein Tag nach einem Feiertag an dem betreffenden Standort ist
+	 */
+//	public static boolean isDayAfterFeiertag(final Date datum, final String firma, final String ndl) {
+//		final GregorianCalendar cal = new GregorianCalendar();
+//		cal.setTime(datum);
+//		cal.add(GregorianCalendar.DAY_OF_YEAR, 1);
+//		return isFeiertag(cal.getTime(), firma, ndl);
+//	}
+
+	/**
+	 * Prüft ob der übergeben eine Feiertag in der Niederlassung ist
+	 * @param datum zu prüfender Tag
+	 * @param firma Firma z. B. 100
+	 * @param ndl Niderlassung z. B. NES
+	 * @return
+	 */
+//	public static boolean isFeiertag(Date datum, String firma, String ndl) {
+//		StringBuilder sqlBuffer = new StringBuilder();
+//		SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
+//		DBHandler dbhandler = null;
+//
+//		try {
+//			
+//			sqlBuffer.append("select int(count(*)) ");
+//			sqlBuffer.append("from GBPADAT where PAFIR1='"+firma+"' and PAFIR2='"+ndl+"' and PAWERT='SENDUNGSZAHLEN' and PAKEY1='FEIERTAGE' and PATXT not like 'GEIS%' ");
+//			sqlBuffer.append("and DAYOFWEEK(date(qgpl2.yymd2iso(int(PAKEY3)*1000000+int(PAKEY4))))>1 ");
+//			sqlBuffer.append("and DAYOFWEEK(date(qgpl2.yymd2iso(int(PAKEY3)*1000000+int(PAKEY4))))<7 ");
+//			sqlBuffer.append("and int(PAKEY3)*1000000+int(PAKEY4)>=" + dateFormat.format(datum) + " ");
+//			sqlBuffer.append("and int(PAKEY3)*1000000+int(PAKEY4)<=" + dateFormat.format(datum) + " ");
+//			
+//			dbhandler = new DBHandler(SchemataENUM.GEISDTA);
+//    		
+//			List<Object[]> res = dbhandler.jdbcSelect(sqlBuffer);
+//
+//			if (res == null)
+//				return false;
+//			
+//			if (res.size() == 0)
+//				return false;
+//			
+//			if (res.get(0)[0] == null)
+//				return false;
+//			
+//			if (((Integer)res.get(0)[0]) > 0)
+//				return true;
+//			
+//		} catch (Exception e) {
+//			e.printStackTrace();
+//			return false;
+//		}
+//		
+//		return false;
+//	}
+
+	/**
+	 * Prüft, ob die gegebenen Datum'se am gleichen Tag sind
+	 * 
+	 * @param date1
+	 * @param date2
+	 * @return boolean - true wenn gleicher Tag
+	 */
+	public static boolean isSameDay(Date date1, Date date2) {
+		Calendar cal1 = Calendar.getInstance();
+		Calendar cal2 = Calendar.getInstance();
+		cal1.setTime(date1);
+		cal2.setTime(date2);
+		return cal1.get(Calendar.DAY_OF_YEAR) == cal2.get(Calendar.DAY_OF_YEAR) && cal1.get(Calendar.YEAR) == cal2.get(Calendar.YEAR);
+	}
+	
+	/**
+	 * Prüft, ob die gegebenen Datum'se die gleiche Uhrzeit haben
+	 * 
+	 * @param date1
+	 * @param date2
+	 * @return boolean - true wenn gleiche Uhrzeit
+	 */
+	public static boolean isSameTime(Date date1, Date date2) {
+		if ((date1 == null && date2 == null) || ((date1 == null) != (date2 == null))) {
+			return false;
+		}
+		Calendar cal1 = Calendar.getInstance();
+		Calendar cal2 = Calendar.getInstance();
+		cal1.setTime(date1);
+		cal2.setTime(date2);
+		return cal1.get(Calendar.HOUR_OF_DAY) == cal2.get(Calendar.HOUR_OF_DAY) && cal1.get(Calendar.MINUTE) == cal2.get(Calendar.MINUTE) && cal1.get(Calendar.SECOND) == cal2.get(Calendar.SECOND);
+	}
+
+	/**
+	 * Prüft, ob das Datum an einem Wochenende ist
+	 * @param datum
+	 * @return boolean - true wenn Wochenende
+	 */
+	public static boolean isWeekend(Date datum) {
+		Calendar cal = new GregorianCalendar();
+		cal.setTimeInMillis(datum.getTime());
+		if (cal.get(GregorianCalendar.DAY_OF_WEEK) == 1 || cal.get(GregorianCalendar.DAY_OF_WEEK) == 7) {
+			return true;
+		}
+		return false;
+	}
+	
+	public static int getWeekNumberCount(int jahr) {
+		Calendar calendar = GregorianCalendar.getInstance();
+    	calendar.set(Calendar.YEAR, jahr);
+    	
+    	int weekNumber = calendar.getActualMaximum(Calendar.WEEK_OF_YEAR);
+		
+		return weekNumber;
+	}
+	
+	public static DateFromTo getDateFromToIntoKW(int year, int weekNumber) {
+		DateFromTo dateFromTo = null;
+		Date dateFrom = null;
+		Date dateTo = null;
+		
+		Calendar cal = Calendar.getInstance();
+	    cal.set(Calendar.YEAR, year);
+	    cal.set(Calendar.WEEK_OF_YEAR, weekNumber);
+	    cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
+	    dateFrom = cal.getTime();
+		
+	    cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
+	    dateTo = cal.getTime();
+	    
+	    dateFromTo = new DateFromTo(dateFrom, dateTo);
+	    
+		return dateFromTo;
+	}
+	
+	/**
+	 * firstDayOfWeek:
+	 * 	SUNDAY = 1,
+	 * 	MONDAY = 2,
+	 * 	...,
+	 * 	SATURDAY = 7
+	 * 
+	 * @param year
+	 * @param weekNumber
+	 * @param firstDayOfWeek
+	 * @return
+	 */
+	public static DateFromTo getDateFromToIntoKW(int year, int weekNumber, int firstDayOfWeek) {
+		DateFromTo dateFromTo = null;
+		Date dateFrom = null;
+		Date dateTo = null;
+		
+		Calendar cal = Calendar.getInstance();
+		cal.setFirstDayOfWeek(firstDayOfWeek);
+	    cal.set(Calendar.YEAR, year);
+	    cal.set(Calendar.WEEK_OF_YEAR, weekNumber);
+	    cal.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
+	    dateFrom = cal.getTime();
+		
+	    cal.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);
+	    dateTo = cal.getTime();
+	    
+	    dateFromTo = new DateFromTo(dateFrom, dateTo);
+	    
+		return dateFromTo;
+	}
+	
+	public static int getKwFromDate(Date date) {
+		Calendar cal = Calendar.getInstance();
+	    cal.setTime(date);
+	    return cal.get(Calendar.WEEK_OF_YEAR);
+	}
+	
+    /**
+     * Rechnet die Tage von 01.01.01 00:00:00 bis zum Übergebenen Datum wobei die Zeit auf 00:00:00 gesetzt wird
+     * @param now Datum z. B. Jetzt oder anderes 
+     * @return Tage zwischen 01.01.01 00:00:00 bis übergebene Datum
+     */
+    public static int getDaysSinceJesus(Date now) {
+		GregorianCalendar today = new GregorianCalendar();
+		today.setTime(now);
+		today.set(GregorianCalendar.HOUR_OF_DAY, 0);
+		today.set(GregorianCalendar.MINUTE, 0);
+		today.set(GregorianCalendar.SECOND, 0);
+		today.set(GregorianCalendar.MILLISECOND, 0);
+		
+		GregorianCalendar jesus = new GregorianCalendar();
+		jesus.set(GregorianCalendar.DAY_OF_YEAR, 1);
+		jesus.set(GregorianCalendar.YEAR, 1);
+		jesus.set(GregorianCalendar.HOUR_OF_DAY, 0);
+		jesus.set(GregorianCalendar.MINUTE, 0);
+		jesus.set(GregorianCalendar.SECOND, 0);
+		jesus.set(GregorianCalendar.MILLISECOND, 0);
+		
+		return (int) (((today.getTime().getTime() - jesus.getTime().getTime()) / (1000 * 60 * 60 * 24)));
+	}
+    
+    /**
+     * Rechnet die Tage seit dem 01.01.01 in ein Datum um
+     * @param days Tage seit 01.01.01
+     * @return Gerechnetes Datum
+     */
+    public static Date getDateFromDaysSinceJesus(int days) {
+		GregorianCalendar jesus = new GregorianCalendar();
+		jesus.set(GregorianCalendar.DAY_OF_YEAR, 1);
+		jesus.set(GregorianCalendar.YEAR, 1);
+		jesus.set(GregorianCalendar.HOUR_OF_DAY, 0);
+		jesus.set(GregorianCalendar.MINUTE, 0);
+		jesus.set(GregorianCalendar.SECOND, 0);
+		jesus.set(GregorianCalendar.MILLISECOND, 0);
+		
+		jesus.add(GregorianCalendar.DAY_OF_YEAR, days+1);
+
+		return jesus.getTime();		
+    }
+
+    /**
+     * Takes today and sets hours, minutes, seconds and milliseconds to zero
+     * @return Date (today 00:00:00)
+     */
+    public static Date getTodayMidnight() {
+		Calendar todayCal = Calendar.getInstance();
+		todayCal.set(Calendar.HOUR_OF_DAY, 0);
+		todayCal.set(Calendar.MINUTE, 0);
+		todayCal.set(Calendar.SECOND, 0);
+		todayCal.set(Calendar.MILLISECOND, 0);
+		return todayCal.getTime();
+	}
+    
+	public static String getTimeBetweenBetweenDates(final Date d1, final Date d2) {
+		return getTimeBetweenBetweenDates(d1.getTime(), d2.getTime());
+	}
+	
+	public static String getTimeBetweenBetweenDates(final long d1, final long d2) {
+		long diff = d2 - d1;
+		long days = TimeUnit.MILLISECONDS.toDays(diff);
+		long hours = TimeUnit.MILLISECONDS.toHours(diff) % 24;
+		long minutes = TimeUnit.MILLISECONDS.toMinutes(diff) % 60;
+		long seconds = TimeUnit.MILLISECONDS.toSeconds(diff) % 60;
+		long milliseconds = diff % 1000;
+		String result = "";
+		if (days > 0) {
+			result += days + "d, ";
+		}
+		if (hours > 0) {
+			result += hours + "h, ";
+		}
+		if (minutes > 0) {
+			result += minutes + "m, ";
+		}
+		if (seconds > 0) {
+			result += seconds + "s, ";
+		}
+		if (milliseconds > 0) {
+			result += milliseconds + "ms";
+		}
+		if (result.isEmpty()) {
+			return "0ms";
+		} else if (result.endsWith(", ")) {
+			return result.substring(0, result.length() - 2); 
+		} else {
+			return result;
+		}
+	}
+	
+	/**
+	 * Get the difference between two dates in hours
+	 * @param date1
+	 * @param date2
+	 * @return difference in hours
+	 */
+	public static int hoursDifference(Date date1, Date date2) {
+	    final int MILLI_TO_HOUR = 1000 * 60 * 60;
+	    return Math.abs((int) (date1.getTime() - date2.getTime()) / MILLI_TO_HOUR);
+	}
+	
+	public static boolean isMidnight(Date d) {
+		GregorianCalendar greg = new GregorianCalendar();
+		greg.setTime(d);
+		greg.set(Calendar.HOUR_OF_DAY, 0);
+		greg.set(Calendar.MINUTE, 0);
+		greg.set(Calendar.SECOND, 0);
+		greg.set(Calendar.MILLISECOND, 0);
+		
+		return d.equals(greg.getTime());
+	}
+	
+	public static Date getEarlierTime(Date date1, Date date2) {
+		Calendar cal1 = Calendar.getInstance();
+		Calendar cal2 = Calendar.getInstance();
+		cal1.setTime(date1);
+		cal2.setTime(date2);
+		
+		cal1.set(GregorianCalendar.DAY_OF_YEAR, 1);
+		cal1.set(GregorianCalendar.YEAR, 1);
+		cal1.set(GregorianCalendar.MILLISECOND, 0);
+		
+		cal2.set(GregorianCalendar.DAY_OF_YEAR, 1);
+		cal2.set(GregorianCalendar.YEAR, 1);
+		cal2.set(GregorianCalendar.MILLISECOND, 0);
+		
+		Date d1 = cal1.getTime();
+		Date d2 = cal2.getTime();
+		
+		return d1.before(d2) ? date1 : date2;
+	}
+
+	public static boolean isSaturday(Date date) {
+		if (date == null) {
+			return false;
+		}
+		Calendar cal1 = Calendar.getInstance();
+		cal1.setTime(date);
+		return cal1.get(GregorianCalendar.DAY_OF_WEEK) == Calendar.SATURDAY;
+	}
+
+	public static boolean isSunday(Date date) {
+		if (date == null) {
+			return false;
+		}
+		Calendar cal1 = Calendar.getInstance();
+		cal1.setTime(date);
+		return cal1.get(GregorianCalendar.DAY_OF_WEEK) == Calendar.SUNDAY;
+	}
+
+	public static Date getNextDay(Date date) {
+		Calendar cal1 = Calendar.getInstance();
+		cal1.setTime(date);
+		cal1.add(GregorianCalendar.DAY_OF_YEAR, 1);
+		return cal1.getTime();
+	}
+}
diff --git a/src/main/java/de/tvo/tools/DoubleUtil.java b/src/main/java/de/tvo/tools/DoubleUtil.java
new file mode 100644
index 0000000..1e4d8dc
--- /dev/null
+++ b/src/main/java/de/tvo/tools/DoubleUtil.java
@@ -0,0 +1,22 @@
+package de.tvo.tools;
+
+import java.text.DecimalFormat;
+
+public class DoubleUtil {
+
+	
+	
+	private static DecimalFormat df = new DecimalFormat( "0.00" );
+	
+	/**
+	 * Konvertiert einen Double zu einem String auf 2 nachkommastellen genau.
+	 * @author Markus Kirchner
+	 * @param Double
+	 * @return String
+	 */
+	public static String convertDoubleToString(Double input) {
+        if (input == null) return df.format(0.0);
+        return df.format(input);
+	}
+	
+}
diff --git a/src/main/java/de/tvo/tools/Exceptions.java b/src/main/java/de/tvo/tools/Exceptions.java
new file mode 100644
index 0000000..58416fa
--- /dev/null
+++ b/src/main/java/de/tvo/tools/Exceptions.java
@@ -0,0 +1,83 @@
+package de.tvo.tools;
+
+import java.sql.Timestamp;
+
+public class Exceptions {
+	
+	public static String createRTStackTrace(final Throwable e) {
+		final StringBuilder stackTrace = new StringBuilder();
+		stackTrace.append(e.getClass().getName());
+		if (e.getMessage() != null && !e.getMessage().trim().isEmpty()) {
+			stackTrace.append(": ");
+			stackTrace.append(e.getMessage());
+		}
+		stackTrace.append("<p style=\"margin-left:32px\">");
+		for (final StackTraceElement element : e.getStackTrace()) {
+			stackTrace.append("at ");
+			stackTrace.append(element.toString());
+			stackTrace.append("<br>");
+		}
+		stackTrace.append("</p>");
+		return stackTrace.toString();
+	}
+	
+	public static String createHTMLStackTrace(final Throwable e) {
+		final StringBuilder stackTrace = new StringBuilder();
+		stackTrace.append("<html><body>");
+		stackTrace.append(e.getClass().getName());
+		if (e.getMessage() != null && !e.getMessage().trim().isEmpty()) {
+			stackTrace.append(": ");
+			stackTrace.append(e.getMessage());
+		}
+		stackTrace.append("<p style=\"margin-left:32px\">");
+		for (final StackTraceElement element : e.getStackTrace()) {
+			stackTrace.append("at ");
+			stackTrace.append(element.toString());
+			stackTrace.append("<br>");
+		}
+		stackTrace.append("</p>");
+		stackTrace.append("</body></html>");
+		return stackTrace.toString();
+	}
+	
+	public static String createStringStackTrace(final Throwable e) {
+		final StringBuilder stackTrace = new StringBuilder();
+		stackTrace.append(e.getClass().getName());
+		if (e.getMessage() != null && !e.getMessage().trim().isEmpty()) {
+			stackTrace.append(": ");
+			stackTrace.append(e.getMessage());
+		}
+		for (final StackTraceElement element : e.getStackTrace()) {
+			stackTrace.append("\tat ");
+			stackTrace.append(element.toString());
+			stackTrace.append('\n');
+		}
+		return stackTrace.toString();
+	}
+	
+	/**
+	 * 
+	 * @return StringBuilder for further appending
+	 * Example:<br>
+	 * 2017-07-07 08:42:54.286 - de.geis.tools.Exceptions.main(Exceptions.java:67)hallO
+	 */
+	public final static StringBuilder createDebugInfos() {
+		return new StringBuilder(new Timestamp(System.currentTimeMillis()).toString()).append(" - ").append(new Exception().getStackTrace()[1].toString());
+	}
+	
+	public final static String prettyPrintGeisException(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);
+			}
+		}
+		if (consolePrint) {
+			System.out.println(builder.toString());
+		}
+		return builder.toString();
+	}
+}
diff --git a/src/main/java/de/tvo/tools/FileUtil.java b/src/main/java/de/tvo/tools/FileUtil.java
new file mode 100644
index 0000000..1ea5bff
--- /dev/null
+++ b/src/main/java/de/tvo/tools/FileUtil.java
@@ -0,0 +1,150 @@
+package de.tvo.tools;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class FileUtil {
+
+	public FileUtil() {
+
+	}
+
+	public static void main(String[] args) {
+
+	}
+
+	/**
+	 * Creating a File
+	 * @param fileName filename (inc. path) to be written to
+	 * @param fileData Content of file to be written
+	 * @param append true : adds content at end. False : adds content at start
+	 * @param debug true : Some Console output. False : No console output
+	 * @return true : Data written. false : Data could not be written
+	 */
+	public static boolean createFile(String fileName, String fileData, boolean append, boolean debug) {
+		if (debug){
+			System.out.println(fileName);
+			System.out.println(fileData);
+		}
+		try {
+			FileWriter f1 = new FileWriter(fileName, append);
+			f1.write(fileData);
+			f1.close();
+			return true;
+		} catch (IOException e) {
+			System.out.println("Fehler beim Erstellen der Datei");
+		}
+		return false;
+	}
+
+	/**
+	 * Creating a File. No Debug
+	 * @param fileName filename (inc. path) to be written to
+	 * @param fileData Content of file to be written
+	 * @param append true : adds content at end. False : adds content at start
+	 * @return true : Data written. false : Data could not be written
+	 */
+	public static boolean createFile(String fileName, String fileData, boolean append) {
+		try {
+			FileWriter f1 = new FileWriter(fileName, append);
+			f1.write(fileData);
+			f1.close();
+			return true;
+		} catch (IOException e) {
+			System.out.println("Fehler beim Erstellen der Datei");
+		}
+		return false;
+	}
+
+	/**
+	 * Deleting a File
+	 * @param file filename (inc. path) to be deleted
+	 * @return true : file deleted. false : file could not be deleted
+	 */
+	public static boolean deleteFile(String file) {
+		try {
+			return new File(file).delete();
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		return false;
+	}
+
+	/**
+	 * Returns a text file with given encoding as StringArray by line
+	 * @param fileName filename (inc. path) to be read
+	 * @param fileEncoding the encoding used by the file
+	 * @return Text of file in StringArray 
+	 * @throws IOException File not Found
+	 * @author miroslav.korbel
+	 */
+	public static String[] readFileAsStringArray(String fileName, String fileEncoding) throws IOException {
+		List<String> lines = new ArrayList<String>();
+		Scanner scanner = new Scanner(new FileInputStream(fileName), fileEncoding);
+		try {
+			while (scanner.hasNextLine()) {
+				lines.add(scanner.nextLine());
+			}
+		} finally {
+			scanner.close();
+		}
+		return lines.toArray(new String[lines.size()]);
+	}
+
+	/**
+	 * Returns a text file as String
+	 * @param fileName filename (inc. path) to be read
+	 * @param debug true : Some Console output. False : No console output
+	 * @return
+	 */
+	public static String loadFile(String fileName, boolean debug) {
+		StringBuilder configBuf = new StringBuilder();
+		int c;
+		try {
+			FileReader f = new FileReader(fileName);
+			while ((c = f.read()) != -1) {
+				configBuf.append((char) c);
+			}
+			f.close();
+		} catch (IOException e) {
+			System.out.println("Fehler beim Lesen der Datei");
+		}
+
+		if (debug)
+			System.out.println(configBuf.toString());
+
+		return configBuf.toString();
+	}
+
+	/**
+	 * Load File
+	 * 
+	 * @param aFileName
+	 * @return
+	 */
+	public static StringBuffer loadFile(String aFileName) {
+		StringBuffer configBuf = new StringBuffer();
+
+		FileReader f;
+		int c;
+
+		try {
+			f = new FileReader(aFileName);
+			while ((c = f.read()) != -1) {
+				configBuf.append((char) c);
+			}
+			f.close();
+		} catch (IOException e) {
+			System.out.println("Fehler beim Lesen der Datei");
+		}
+
+		return configBuf;
+	}
+
+}
diff --git a/src/main/java/de/tvo/tools/FilterUtil.java b/src/main/java/de/tvo/tools/FilterUtil.java
new file mode 100644
index 0000000..b87a8f1
--- /dev/null
+++ b/src/main/java/de/tvo/tools/FilterUtil.java
@@ -0,0 +1,87 @@
+package de.tvo.tools;
+
+/**
+ * @author Schneidele
+ * @version 1.0
+ */
+
+public class FilterUtil {
+	
+	public FilterUtil() {
+	}
+	
+	public static void main(String[] args) {
+	}
+	
+	/**
+	 * @author Schneidele
+	 * @param user Current User
+	 * @param suchItem Map mit Werten für Speicherung der Filter (key)(value)
+	 * @param test Test/Echt
+	 * @param segment Segment für Properties
+	 * @param key Speicherort für Properties
+	 * @see #loadFilterInfos(String, boolean, String, String) Laden der gespeicherten Filter
+	 */
+//	public static void saveFilterInfos(String user, Map<?, ?> suchItem, boolean test, String segment, String key) {
+//		Set<?> set = suchItem.entrySet();
+//	    Iterator<?> itr = set.iterator();  
+//		GpconfigWorker gpconfigWorker = new GpconfigWorker(test);
+//		if (user == null || user.isEmpty()) {
+//			return;
+//		}
+//		Properties prop = new Properties();
+//		while(itr.hasNext()){  
+//	        @SuppressWarnings("rawtypes")
+//			Map.Entry entry = (Map.Entry)itr.next();  
+//	        prop.setProperty(entry.getKey().toString(), entry.getValue().toString());
+//	    } 
+//		try {
+//			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+//			prop.store(baos, "");
+//			gpconfigWorker.createConfigInDBwithUser(segment, key, baos.toString(), user, user);
+//			OKPopup.createInstance("Filter gespeichert", "Filtereinstellungen erfolgreich gespeichert!");
+//		} catch (Exception e) {
+//			e.printStackTrace();
+//			OKPopup.createInstance("Fehler", "Fehler beim Speichern der Filtereinstellungen!");
+//		}
+//	}
+	
+	/**
+	 * @author Schneidele
+	 * @param user Current User
+	 * @param test Test/Echt
+	 * @param workerSegment Segment der Properties
+	 * @param workerKey Speicherort der Properties
+	 * @see #saveFilterInfos(String, Map, boolean, String, String) Speichern der Filter
+	 */
+//	public static Map<?, ?> loadFilterInfos(String user, boolean test, String workerSegment, String workerKey) {
+//		String value = "";
+//		GpconfigWorker gpconfigWorker = new GpconfigWorker(test);
+//		Map<String, String> loadedItems = new HashMap<String, String>();
+//		if ("STANDARD".equals(workerKey)) {
+//			value = gpconfigWorker.getValueFromGpconfig(workerSegment, workerKey, null);
+//		} else {
+//			value = gpconfigWorker.getValueFromGpconfig(workerSegment, workerKey, user);
+//		}
+//		if (StringUtil.safeIsBlank(value)) {
+//			return null;
+//		}
+//		Properties props = new Properties();
+//		InputStream is = new ByteArrayInputStream(value.getBytes());
+//		try {
+//			props.load(is);
+//		} catch (IOException e) {
+//			e.printStackTrace();
+//			String t = "Beim Laden der Einstellungen ist ein Fehler aufgetreten.";
+//			OKPopup.createInstance("Fehler", t).getModalPopup().setLeftTopReferenceCentered();
+//			return null;
+//		}
+//		props.forEach((key, val) -> {
+//			if (!StringUtil.safeIsBlankObj(val)) {
+//				loadedItems.put(key.toString(), val.toString());
+//			}
+//		});
+//		return loadedItems;
+//	}
+
+}
diff --git a/src/main/java/de/tvo/tools/HtmlUtil.java b/src/main/java/de/tvo/tools/HtmlUtil.java
new file mode 100644
index 0000000..70eeb51
--- /dev/null
+++ b/src/main/java/de/tvo/tools/HtmlUtil.java
@@ -0,0 +1,140 @@
+package de.tvo.tools;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * @author Schneidele
+ * @version 1.0
+ */
+
+public class HtmlUtil {
+	
+	public HtmlUtil() {
+		
+	}
+
+	public static void main(String[] args) {
+
+	}
+	
+	/**
+	 * @author Schneidele
+	 * @param source String zum umwandeln
+	 * @return Gibt umgewandelten String mit HTML Tags als Liste zurück.
+	 * @see #createListWithBold(String) Liste mit Fettschrift
+	 */
+	public static String createList(String source) {
+		return source.replaceFirst("-", "<li>") + "</li>";
+	}
+	
+	/**
+	 * @author Schneidele
+	 * @param source String zum umwandeln
+	 * @return Gibt umgewandelten String mit HTML Tags als Liste und Fettschrift zurück.
+	 * @see #createList(String) Liste ohne Fettschrift
+	 * @see #createBoldText(String) Paragraph mit Fettschrift
+	 */
+	public static String createListWithBold(String source) {
+		if (source.contains(" **")) {
+			return source.replaceFirst("-", "<li>").replace(" **", " <b>").replace("** ", "</b> ") + "</li>";
+		} else {
+			final String regex = "\\*\\*(.*)\\*\\*";
+			final Pattern pattern = Pattern.compile(regex);
+	        final Matcher matcher = pattern.matcher(source);
+	        if (matcher.find()) {
+	            return source.replaceFirst("-", "<li>").replace(matcher.group(0), "<b>" + matcher.group(1) + "</b>") + "</li>";
+	        } else {
+				return source.replaceFirst("-", "<li>") + "</li>";
+			}
+		}
+	}
+	
+	/**
+	 * @author Schneidele
+	 * @param source String zum umwandeln
+	 * @return Gibt umgewandelten String mit HTML Tags als Paragraph zurück.
+	 */
+	public static String createParagraph(String source) {
+		return "<p>" + source + "</p>";
+	}
+	
+	/**
+	 * @author Schneidele
+	 * @param source String zum umwandeln
+	 * @return Gibt umgewandelten String mit HTML Tags als Header zurück.<br>
+	 * "#" --> "h1"<br>
+	 * "##" --> "h2"<br>
+	 * "###" --> "h3"<br>
+	 * "####" --> "h4"<br>
+	 * "#####" --> "h5"<br>
+	 * "######" --> "h6"
+	 */
+	public static String createHeader(String source) {
+		int hashCounter = 0;
+		for (int i = 0; i < source.length(); i++) {
+			if (source.substring(i, i+1).equals("#")) {
+				hashCounter++;
+			}
+		}
+		if (hashCounter == 1) {
+			return source.replaceFirst("#", "<h1>") + "</h1><hr>";
+		} else if (hashCounter == 2) {
+			return source.replaceFirst("##", "<h2>") + "</h2><hr>";
+		} else if (hashCounter == 3) {
+			return source.replaceFirst("###", "<h3>") + "</h3>";
+		} else if (hashCounter == 4) {
+			return source.replaceFirst("####", "<h4>") + "</h4>";
+		} else if (hashCounter == 5) {
+			return source.replaceFirst("#####", "<h5>") + "</h5>";
+		} else {
+			return source.replaceFirst("######", "<h6>") + "</h6>";
+		}
+	}
+	
+	/**
+	 * @author Schneidele
+	 * @param source String zum umwandeln
+	 * @return Gibt eine "Breakline" "_______" über die gesamte Seite zurück.
+	 */
+	public static String createBreakLine(String source) {
+		return source.replace("___", "<hr>");
+	}
+	
+	/**
+	 * @author Schneidele
+	 * @param source String zum umwandeln
+	 * @return Gibt umgewandelten String mit HTML Tags als Fettschrift zurück.
+	 */
+	public static String createBoldText(String source) {
+		if (source.contains(" **")) {
+			return source.replace(" **", " <b>").replace("** ", "</b> ");
+		} else {
+			final String regex = "\\*\\*(.*)\\*\\*";
+			final Pattern pattern = Pattern.compile(regex);
+	        final Matcher matcher = pattern.matcher(source);
+	        if (matcher.find()) {
+	            return source.replace(matcher.group(0), "<b>" + matcher.group(1) + "</b>");
+	        } else {
+				return source;
+			}
+		}
+	}
+	
+	/**
+	 * @author Schneidele
+	 * @param source String zum umwandeln
+	 * @return Gibt umgewandelten String mit HTML Tags als Bild zurück.
+	 */
+	public static String createImage(String source) {
+		final String regex = ".*\\((.*)\\).*";
+		final Pattern pattern = Pattern.compile(regex);
+        final Matcher matcher = pattern.matcher(source);
+        if (matcher.find()) {
+            return "<img src=\"https://git.de.geis-group.net/risc/wiki_glog_gtms/-/wikis/" + matcher.group(1) + "\" alt=\"Bild\">";
+        } else {
+        	return "<p style=\"color:red\"> <b>[!ERROR!]</b> Bild konnte nicht geladen werden </p>";
+		}
+	}
+
+}
diff --git a/src/main/java/de/tvo/tools/HttpUtil.java b/src/main/java/de/tvo/tools/HttpUtil.java
new file mode 100644
index 0000000..a22ecea
--- /dev/null
+++ b/src/main/java/de/tvo/tools/HttpUtil.java
@@ -0,0 +1,34 @@
+package de.tvo.tools;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+
+public class HttpUtil {
+
+	/**
+	 * Download file from given URL, returning file as byte array
+	 * 
+	 * @param urlString
+	 * @return byte [], or null if error
+	 */
+	public static byte[] downloadUrl(String urlString) {
+		byte[] byteArray = null;
+		try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
+			URL url = new URL(urlString);
+			byte[] chunk = new byte[4096];
+			int bytesRead;
+			InputStream stream = url.openStream();
+			while ((bytesRead = stream.read(chunk)) > 0) {
+				outputStream.write(chunk, 0, bytesRead);
+			}
+			byteArray = outputStream.toByteArray();
+		} catch (IOException e) {
+			e.printStackTrace();
+			return null;
+		}
+		return byteArray;
+	}
+
+}
diff --git a/src/main/java/de/tvo/tools/MapUtil.java b/src/main/java/de/tvo/tools/MapUtil.java
new file mode 100644
index 0000000..9571482
--- /dev/null
+++ b/src/main/java/de/tvo/tools/MapUtil.java
@@ -0,0 +1,44 @@
+package de.tvo.tools;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class MapUtil {
+
+	/**
+	 * @param map
+	 *            Map&lt;Object, List&lt;Object&gt;&gt;
+	 */
+	@SuppressWarnings("rawtypes")
+	public final static String prettyPrintMapOfObjectList(final Map map, boolean printOut) {
+		StringBuilder prettyPrinted = new StringBuilder();
+		for (final Object key : map.keySet()) {
+			prettyPrinted.append("Key: \"").append(StringUtil.safeTrimObjWithReplace(key)).append("\"\n");
+			for (final Object value : (List) map.get(key)) {
+				prettyPrinted.append("\tValue: \"").append(StringUtil.safeTrimObjWithReplace(value)).append("\"\n");
+			}
+		}
+		if (printOut) {
+			System.out.println(prettyPrinted.toString());
+		}
+		return prettyPrinted.toString();
+	}
+
+	/**
+	 * @param map
+	 *            Map&lt;Object,Object&gt;
+	 */
+	@SuppressWarnings({ "rawtypes" })
+	public final static String prettyPrintMapOfObjects(final Map map, boolean printOut) {
+		StringBuilder prettyPrinted = new StringBuilder();
+		for (final Object set : map.entrySet()) {
+			prettyPrinted.append("Key: \"").append(StringUtil.safeTrimObjWithReplace(((Entry) set).getKey())).append("\" - Value: \"").append(StringUtil.safeTrimObjWithReplace(((Entry) set).getValue())).append("\"\n");
+		}
+		if (printOut) {
+			System.out.println(prettyPrinted.toString());
+		}
+		return prettyPrinted.toString();
+	}
+
+}
diff --git a/src/main/java/de/tvo/tools/ObjectUtil.java b/src/main/java/de/tvo/tools/ObjectUtil.java
new file mode 100644
index 0000000..08ab7a1
--- /dev/null
+++ b/src/main/java/de/tvo/tools/ObjectUtil.java
@@ -0,0 +1,146 @@
+package de.tvo.tools;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class ObjectUtil {
+	/**
+	 * EN: Setter for object with function "SET"
+	 * 
+	 * @param obj
+	 *            name of object for data input
+	 * @param dbFieldName
+	 *            name of set method without "SET"
+	 * @param value
+	 *            value to insert into obj
+	 * @return true if object inserted(Setted)
+	 */
+	public static boolean objectSetter(Object obj, String dbFieldName, Object value) {
+		for (java.lang.reflect.Method method : obj.getClass().getMethods()) {
+//			System.out.println(method.toString());
+			if (method.toString().toUpperCase().contains("SET" + dbFieldName.toUpperCase()+"("))
+				try {
+					method.invoke(obj, value);
+					return true;
+				} catch (SecurityException e) {
+					e.printStackTrace();
+				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+					e.printStackTrace();
+				}
+		}
+		return false;
+	}
+
+	/**
+	 * EN: Getter for object with function "GET"
+	 * 
+	 * @param obj
+	 *            name of object for data output
+	 * @param dbFieldName
+	 *            name of get method without "GET"
+	 * @return return Object if fount or null
+	 */
+	public static Object objectGetter(Object obj, String dbFieldName) {
+		for (java.lang.reflect.Method method : obj.getClass().getMethods()) {
+			if (method.toString().toUpperCase().contains("GET" + dbFieldName.toUpperCase()))
+				try {
+					return method.invoke(obj);
+				} catch (SecurityException e) {
+					e.printStackTrace();
+				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+					e.printStackTrace();
+				}
+		}
+		return null;
+	}
+
+	/**
+	 * Trimmer for all String filed in Object.
+	 * 
+	 * @param obj
+	 *            object with set and get String fields,
+	 */
+	public static void dbOjectTrimmer(Object obj) {
+		for (Method method : obj.getClass().getMethods()) {
+			if (method.toString().toUpperCase().contains(".GET"))
+				try {
+					if(method.getName().substring(3).equals("Class")) {
+						continue;
+					}
+//					System.out.println("Prepare : " + method.getName().substring(3));
+					Object result = method.invoke(obj);
+					if (result instanceof String) {
+						if (objectSetter(obj, method.getName().substring(3), StringUtil.safeTrimObj(result))) {
+//							System.out.println("TRIMMED:" + method.getName().substring(3) + " = " + StringUtil.safeTrimObj(result));
+						}
+					}
+				} catch (SecurityException e) {
+					e.printStackTrace();
+				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+					e.printStackTrace();
+				}
+		}
+	}
+	
+	/**
+	 * Function to compare two different Object of any kind. It doesnt matter
+	 * wheter its public or private. If a null or different kind of Classes are given
+	 * the function returns an Exception. 
+	 * Fabian claims he`d helped
+	 * 
+	 * @param newObject
+	 * @param oldObject
+	 * @return True if Object differs
+	 */
+	@SuppressWarnings("null")
+	public static boolean isDifferent(Object newObject, Object oldObject) throws Exception {
+		if (newObject == null || oldObject == null || !newObject.getClass().equals(oldObject.getClass())) {
+			throw new Exception("\"This wasnt S M R T\" - Fabian Hüllmantel");
+		}
+		Field[] newFields = newObject.getClass().getDeclaredFields();
+		for (Field o : newFields) {
+			if (!o.isAccessible()) {
+				o.setAccessible(true);
+			}
+			String oldO = null;
+			String newO = null;
+			if (o.get(oldObject)!= null){
+				oldO = StringUtil.safeTrim(o.get(oldObject).toString());
+			}
+			if (o.get(newObject)!= null){
+				newO = StringUtil.safeTrim(o.get(newObject).toString());
+			}
+			if (oldO == null && newO == null) {
+				continue;
+			}
+			if ((oldO == null && newO != null) || (oldO != null && newO == null) || (!oldO.trim().equals(newO.trim()))) {
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * This function will print out all variable names and values of an object on the console 
+	 * @param obj - The object which you want to get more info on the console
+	 */
+	public static void objectToConsole(final Object obj) {
+		try {
+			for (final Field field : obj.getClass().getDeclaredFields()) {
+				try {
+					if (!field.isAccessible()) {
+						field.setAccessible(true);
+					}
+					Object value = field.get(obj);
+					System.out.println("variable: \"" + field.getName() + "\", value: \"" + value + '"');
+				} catch (final Exception e) {
+					e.printStackTrace();
+				}
+			}
+		} catch (final Exception e) {
+			e.printStackTrace();
+		}
+	}
+
+}
diff --git a/src/main/java/de/tvo/tools/SqlUtil.java b/src/main/java/de/tvo/tools/SqlUtil.java
new file mode 100644
index 0000000..ee658cc
--- /dev/null
+++ b/src/main/java/de/tvo/tools/SqlUtil.java
@@ -0,0 +1,153 @@
+package de.tvo.tools;
+
+import java.sql.Timestamp;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+
+import org.hibernate.engine.jdbc.internal.BasicFormatterImpl;
+
+import de.tvo.global.PreparedStatementData;
+
+/**
+ * DE: 
+ *
+ * EN: 
+ * 
+ * 
+ * Program changes
+ * **************************************************************************************
+ * Date			* Ticket	* KonzFirm	* Responsible	* programmer    *
+ * Change										*
+ * **************************************************************************************
+ *
+ * @author VogelT
+ * @version 1.0
+ *
+ */
+
+public abstract class SqlUtil {
+
+	public static final String getSqlInForStringValue(final List<String> inValueList) {
+		StringBuilder inBuffer = new StringBuilder();
+	       
+	    for (final String value : inValueList) {
+	    	inBuffer.append('\'');
+	    	inBuffer.append(StringUtil.safeTrim(value));
+	    	inBuffer.append("',");
+	    }
+	       
+	    if (!inBuffer.toString().trim().isEmpty()) {
+	    	return inBuffer.toString().substring(0, inBuffer.toString().trim().length() -1);
+	    } 
+	    return null;
+	}
+	
+	public static final String getSqlInForNumericValue(final List<?> inValueList) {
+		StringBuilder inBuffer = new StringBuilder();
+	       
+	    for (final Object value : inValueList) {
+	    	String trimmedValue = StringUtil.safeTrimObjWithReplace(value);
+	    	if (!trimmedValue.isEmpty()) {
+		    	inBuffer.append(StringUtil.safeTrimObjWithReplace(value));
+		    	inBuffer.append(",");
+	    	}
+	    }
+	       
+	    if (!inBuffer.toString().trim().isEmpty()) {
+	    	return inBuffer.toString().substring(0, inBuffer.toString().trim().length() -1);
+	    } 
+	    return null;
+	}
+	
+	public static final String getSqlFields(final List<?> fieldList) {
+		StringBuilder inBuffer = new StringBuilder();
+	       
+	    for (final Object value : fieldList) {
+	    	String trimmedValue = StringUtil.safeTrimObjWithReplace(value);
+	    	if (!trimmedValue.isEmpty()) {
+		    	inBuffer.append(StringUtil.safeTrimObjWithReplace(value));
+		    	inBuffer.append(",");
+	    	}
+	    }
+	       
+	    if (!inBuffer.toString().trim().isEmpty()) {
+	    	return inBuffer.toString().substring(0, inBuffer.toString().trim().length() -1);
+	    } 
+	    return null;
+	}
+	
+	public static String getFilledPreparedStatement(String sqlQuery, PreparedStatementData psd) {
+	    try {
+	    	String[] parts = sqlQuery.split("\\?");
+		    StringBuilder sb = new StringBuilder();
+
+		    Iterator<Object> iterator = psd.values().iterator();
+		    for (int i = 0; i < parts.length; i++) {
+		        String part = parts[i];
+		        sb.append(part);
+		        if (i < psd.size()) {
+		            sb.append(formatParameter(iterator.next()));
+		        }
+		    }
+		   return new BasicFormatterImpl().format(sb.toString());
+		}
+		catch (Exception e) {
+			throw e;
+		}
+	}
+	
+	public static void main(String[] args) {
+		Map<String, String> m = new TreeMap<String, String>();
+		m.put("Key1", "Value1");
+		m.put("Key2", "Value2");
+		
+		System.out.println(generateSQLConditionFromMap(m));
+	}
+	
+	/**
+	 * Erstellt einen SQL für eine WHERE-Bedingung
+	 * @param map Key-Value-Map für die SQL-Bedingung
+	 * @return String aus der map gebaut
+	 */
+	public static String generateSQLConditionFromMap(final Map<String, ?> map) {
+		return map.entrySet().stream()
+			.map(e -> new StringBuilder().append(e.getKey().toLowerCase()).append("='").append(e.getValue()).append('\''))
+			.collect(Collectors.joining(" AND "));
+	}
+	
+	/**
+	 * Erstellt einen SQL für eine WHERE-Bedingung
+	 * @param map Key-Value-Map für die SQL-Bedingung
+	 * @return String aus der map gebaut
+	 */
+	public static String generateSQLConditionFromMapWithComma(final Map<String, ?> map) {
+		return map.entrySet().stream()
+			.map(e -> new StringBuilder().append(e.getKey().toLowerCase()).append("='").append(e.getValue()).append('\''))
+			.collect(Collectors.joining(" , "));
+	}
+
+	private static String formatParameter(Object parameter) {
+	    if (parameter == null) {
+	        return "NULL";
+	    } else {
+	        if (parameter instanceof String) {
+	            return "'" + ((String) parameter).replace("'", "''") + "'";
+	        } else if (parameter instanceof Timestamp) {
+	            return "to_timestamp('" + new SimpleDateFormat("MM/dd/yyyy HH:mm:ss.SSS").
+	                    format(parameter) + "', 'mm/dd/yyyy hh24:mi:ss.ff3')";
+	        } else if (parameter instanceof Date) {
+	            return "to_date('" + new SimpleDateFormat("MM/dd/yyyy HH:mm:ss").
+	                    format(parameter) + "', 'mm/dd/yyyy hh24:mi:ss')";
+	        } else if (parameter instanceof Boolean) {
+	            return ((Boolean) parameter).booleanValue() ? "1" : "0";
+	        } else {
+	            return parameter.toString();
+	        }
+	    }
+	}
+}
diff --git a/src/main/java/de/tvo/tools/Stoppuhr.java b/src/main/java/de/tvo/tools/Stoppuhr.java
new file mode 100644
index 0000000..bd29d5e
--- /dev/null
+++ b/src/main/java/de/tvo/tools/Stoppuhr.java
@@ -0,0 +1,173 @@
+package de.tvo.tools;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+public class Stoppuhr {
+
+	/**
+	 * Klasse die den MsgText, 
+	 * @author Thomas?
+	 *
+	 */
+	class Timer {
+
+		public Timer(String msg) {
+			this.i_startDate = new Date();
+			this.i_msg = msg;
+		}
+
+		String i_msg = null;
+		Date i_startDate = null;
+		Date i_endDate = null;
+		long i_diffmsec = 0;
+
+		//TODO warum hier nicht : return getDiffmsec() + " msec - " + i_msg
+		public String getMsg() {
+			return i_msg;
+		}
+
+		public void setMsg(String msg) {
+			i_msg = msg;
+		}
+
+		public Date getStartDate() {
+			return i_startDate;
+		}
+
+		public void setStartDate(Date startDate) {
+			i_startDate = startDate;
+		}
+
+		public Date getEndDate() {
+			return i_endDate;
+		}
+
+		public void setEndDate(Date endDate) {
+			i_endDate = endDate;
+		}
+
+		
+		//TODO warum hier nicht : return enddate - startdate?
+		public long getDiffmsec() {
+			return i_diffmsec;
+		}
+
+		public void setDiffmsec(long diffmsec) {
+			i_diffmsec = diffmsec;
+		}
+
+	}
+
+	private boolean aktivStoppuhr = false;
+
+	public Stoppuhr(boolean aktiv) {
+		this.aktivStoppuhr = aktiv;
+		if (aktivStoppuhr) {
+			init();
+		}
+	}
+
+	public void init() {
+		timerListe = new ArrayList<Stoppuhr.Timer>();
+		timerClass = new Timer("Stoppuhr run Total.");
+	}
+
+	public static void main(String[] args) {
+		Stoppuhr stoppuhr = new Stoppuhr(true);
+		try {
+			stoppuhr.start("Test 1");
+
+			Thread.sleep(100);
+
+			stoppuhr.timestamp();
+
+			stoppuhr.start("Test 2");
+
+			Thread.sleep(50);
+
+			stoppuhr.stop();
+
+			System.out.println(stoppuhr.show());
+
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+
+	}
+
+	private Timer timerClass = null;
+	private Timer timerAktuell = null;
+
+	private Date timerDate;
+	private Date endDate;
+
+	List<Timer> timerListe = null;
+
+	public void start(String msg) {
+		if (aktivStoppuhr) {
+			timerAktuell = new Timer(msg);
+		}
+	}
+
+	public void stop() {
+		if (aktivStoppuhr) {
+			timestamp();
+			endDate = new Date();
+			timerClass.setEndDate(endDate);
+			timerClass.setDiffmsec(diffStartEndDate(timerClass.getStartDate(), timerClass.getEndDate()));
+		}
+	}
+
+	public void timestamp() {
+		if (aktivStoppuhr) {
+			timerDate = new Date();
+			timerAktuell.setEndDate(timerDate);
+			timerAktuell.setDiffmsec(diffStartEndDate(timerAktuell.getStartDate(), timerAktuell.getEndDate()));
+			timerListe.add(timerAktuell);
+			timerDate = new Date();
+		}
+	}
+
+	public void stopAndShow() {
+		if (aktivStoppuhr) {
+			stop();
+			System.out.println(show());
+		}
+	}
+
+	public String show() {
+		StringBuffer msgBuffer = new StringBuffer();
+		if (aktivStoppuhr) {
+			msgBuffer.append(msgBuild(timerClass.getMsg(), timerClass.getDiffmsec()));
+
+			for (int i = 0; i < timerListe.size(); i++) {
+				Timer timer = timerListe.get(i);
+				msgBuffer.append("\r\n");
+				msgBuffer.append(msgBuild(timer.getMsg(), timer.getDiffmsec()));
+
+			}
+		}
+
+		return msgBuffer.toString();
+	}
+
+	private long diffStartEndDate(Date start, Date end) {
+		long result = 0;
+
+		result = end.getTime() - start.getTime();
+
+		return result;
+	}
+
+	private String msgBuild(String msg, long diff) {
+		return diff + " msec - " + msg;
+	}
+
+	public void nextStep(String text) {
+		timestamp();
+		start(text);
+	}
+
+}
diff --git a/src/main/java/de/tvo/tools/XMLUtils.java b/src/main/java/de/tvo/tools/XMLUtils.java
new file mode 100644
index 0000000..1033e93
--- /dev/null
+++ b/src/main/java/de/tvo/tools/XMLUtils.java
@@ -0,0 +1,49 @@
+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/DBTools.java b/src/main/java/de/tvo/toolset/DBTools.java
new file mode 100644
index 0000000..c343a77
--- /dev/null
+++ b/src/main/java/de/tvo/toolset/DBTools.java
@@ -0,0 +1,226 @@
+package de.tvo.toolset;
+
+import java.lang.reflect.Field;
+import java.util.Date;
+import java.util.List;
+
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+
+import org.hibernate.engine.jdbc.internal.BasicFormatterImpl;
+
+public class DBTools {
+	
+	public enum SchemataENUM{
+		GEISV8E, GEICOMV5, GEICOMV8, GEIDATV5, GEIDATV8, GEISDTA, GEISDTT, GEISZBV, GEISZBVT, LWIS12DTA, LWIS12DTT, GEISV8T, TSTCOMV5, TSTCOMV8, TSTDATV5, TSTDATV8, GEISWPT, GEISWPE, GEISPGM, IMGTST, IMGPRD , DWH_CORE, TESTV8, ECHTV8, GTMS, GTMS5, MARIADBCRM, DWH_ROADMAP, GEISTBT, GEISTBE, 
+	}
+	
+	public static DbENUM getDBName(SchemataENUM schema){
+		switch (schema) {
+		/* DB2 / AS400 Schematas */		
+			case GEISV8E:
+			case GEICOMV5:
+			case GEICOMV8:
+			case GEIDATV8:
+			case GEIDATV5:
+			case GEISDTA:
+			case GEISDTT:
+			case GEISZBV:
+			case GEISZBVT:
+			case LWIS12DTA:
+			case LWIS12DTT:
+			case GEISV8T:
+			case TSTCOMV5:
+			case TSTCOMV8:
+			case TSTDATV5:
+			case TSTDATV8:
+			case GEISPGM:
+			case IMGTST:
+			case IMGPRD:
+			case TESTV8:
+			case ECHTV8:
+			case GEISTBT:	
+			case GEISTBE:
+				return DbENUM.DB2;
+			
+			case GEISWPE:
+			case GEISWPT:
+				return DbENUM.DB2SYS;
+				
+			case GTMS:
+				return DbENUM.DB2GTMS;
+			
+			case GTMS5:
+				return DbENUM.DB2GTMS5;
+				
+//		 MSSQL DWH Schematas 
+			case DWH_CORE:
+				return DbENUM.MSSQL_DWH;
+			
+			case DWH_ROADMAP:
+				return DbENUM.MSSQL_DWH_ROADMAP;
+				
+			
+			case MARIADBCRM:
+				return DbENUM.MARIADBCRM;
+				
+		/* MYSQL Schematas 	
+		return DbENUM.MYSQL;
+		
+		Default Rückfall */		
+		default:
+			return DbENUM.DB2;
+		}
+	}
+	
+	public static String getJNDIConnectionString(SchemataENUM schema){
+		switch (getDBName(schema)) {
+		/* DB2 / AS400 Schematas */		
+			case DB2:
+				return "java:comp/env/jdbc/db2";
+		
+		/* DB2 / AS400 Schematas SYSTEM */		
+			case DB2SYS:
+				return "java:comp/env/jdbc/db2sys";
+				
+		/* DB2 GTMS / AS400 Schematas */
+			case DB2GTMS:
+				return "java:comp/env/jdbc/db2gtms";
+
+		/* DB2 GTMS / AS400 Schematas GEISAS05 */
+			case DB2GTMS5:
+				return "java:comp/env/jdbc/db2gtms5";
+
+		/* MSSQL Schematas */	
+			case MSSQL_DWH:
+				return "java:comp/env/jdbc/mssqldwh";
+				
+			case MSSQL_DWH_ROADMAP:
+				return "java:comp/env/jdbc/mssqldwhroadmap";
+			
+		/* MYSQL Schematas 	*/	
+			case MYSQL:
+				return "java:comp/env/jdbc/mysql";
+			
+			case MARIADBCRM:
+				return "java:comp/env/jdbc/mariadbcrm";
+				
+		/* Default Rückfall 	*/	
+			default:
+				return "java:comp/env/jdbc/db2sys";
+		}
+	}
+	
+	public enum DbENUM{
+		DB2,DB2SYS,DB2GTMS,DB2GTMS5,MSSQL_DWH,MYSQL,MSSQL,MARIADBCRM,MSSQL_DWH_ROADMAP
+	}
+	
+	/**
+	 * Check method which compares a hibernate object with the annotation metadata to see if everything is fine
+	 * @param obj - object which is going to be tested
+	 * @return if the object is a valid hibernate PoJo and correctly filled along it annotations
+	 */
+	public static boolean validateHibernateObject(final Object obj) {
+		if (obj == null) {
+			return false;
+		}
+		
+		if (obj instanceof List) {
+			boolean result = true;
+			for (Object listObj : (List<?>) obj) {
+				if (!validateHibernateObject(listObj)) {
+					result = false;
+				}
+			}
+			return result;
+		}
+		
+		Entity e = obj.getClass().getAnnotation(Entity.class);
+		if (e == null) {
+			System.out.println("Not a valid Hibernate Entity");
+			return false;
+		} else {
+			try {
+				boolean result = true;
+				for (Field f: obj.getClass().getDeclaredFields()) {
+					f.setAccessible(true);
+
+					Id id = f.getAnnotation(Id.class);
+					if (id != null) {
+						System.out.println(f.getName() + " is an ID-Field, filled with: \"" + f.get(obj) +"\"");
+						continue;
+					}
+					
+					Column c = f.getAnnotation(Column.class);
+					if (c == null) {
+						//System.out.println("not a column, just a normal field");
+						continue;
+					}
+					
+					Object objectInField = f.get(obj);
+					
+					if (objectInField == null) {
+						if (!c.nullable()) {
+							result = false;
+							System.out.println("Non nullable field " + f.getName() + " is null");
+						}
+						continue;
+					}
+					
+					if (f.getType() == String.class) {
+						if (c.length() < ((String) objectInField).length()) {
+							result = false;
+							System.out.println("Max length of " + f.getName() + " is " + c.length() + " but you have " + ((String) objectInField).length());
+						}
+					} else if (f.getType() == Date.class) {
+						//Fine, just check nullable
+					} else if (f.getType() == Short.class) {
+						Short s = (Short) objectInField;
+						if (s.toString().length() > c.precision()) {
+							result = false;
+							System.out.println("Max precision of " + f.getName() + " is " + c.precision() + " but you have " + s.toString().length());
+						}
+					}  else if (f.getType() == Integer.class) {
+						Integer i = (Integer) objectInField;
+						if (i.toString().length() > c.precision()) {
+							result = false;
+							System.out.println("Max precision of " + f.getName() + " is " + c.precision() + " but you have " + i.toString().length());
+						}
+					} else if (f.getType() == Long.class) {
+						Long l = (Long) objectInField;
+						if (l.toString().length() > c.precision()) {
+							result = false;
+							System.out.println("Max precision of " + f.getName() + " is " + c.precision() + " but you have " + l.toString().length());
+						}
+					} else if (f.getType() == Date.class) {
+						//Fine, just check nullable
+					} else if (f.getType() == Float.class) {
+						int maxLengthBeforeDecimalPoint = c.precision()-c.scale();
+						Float fl = (Float) objectInField;
+						if (String.valueOf(fl.longValue()).length() > maxLengthBeforeDecimalPoint) {
+							System.out.println("Max precision-scale of " + f.getName() + " is " + maxLengthBeforeDecimalPoint + " but you have " + String.valueOf(fl.longValue()).length());
+						}
+					} else if (f.getType() == Double.class) {
+						int maxLengthBeforeDecimalPoint = c.precision()-c.scale();
+						Double d = (Double) objectInField;
+						if (String.valueOf(d.longValue()).length() > maxLengthBeforeDecimalPoint) {
+							System.out.println("Max precision-scale of " + f.getName() + " is " + maxLengthBeforeDecimalPoint + " but you have " + String.valueOf(d.longValue()).length());
+						}
+					} else {
+						System.out.println("Unkown field typ " + f.getClass() + " in field " + f.getName());
+						result = false;
+					}
+				}
+				return result;
+			} catch (final Exception ex) {
+				ex.printStackTrace();
+				return false;
+			}
+		}
+	}
+	
+	public static String prettyFormatSQL(final CharSequence sql) {
+		return new BasicFormatterImpl().format(sql.toString());
+	}
+}
diff --git a/src/main/java/de/tvo/toolset/DatabaseUpdateHandler.java b/src/main/java/de/tvo/toolset/DatabaseUpdateHandler.java
new file mode 100644
index 0000000..31f53fd
--- /dev/null
+++ b/src/main/java/de/tvo/toolset/DatabaseUpdateHandler.java
@@ -0,0 +1,304 @@
+package de.tvo.toolset;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import de.tvo.database.DBHandler;
+import de.tvo.tools.SqlUtil;
+import de.tvo.tools.StringUtil;
+import de.tvo.toolset.DBTools.SchemataENUM;
+
+public class DatabaseUpdateHandler {
+
+	private final boolean m_test;
+
+	public boolean getTest() {
+		return m_test;
+	}
+
+	private final SchemataENUM m_schemataENUM;
+
+	public SchemataENUM getSchemataENUM() {
+		return m_schemataENUM;
+	}
+
+	private DBHandler m_dbHandler;
+
+	public DBHandler getDbHandler() {
+		if (m_dbHandler == null) {
+			m_dbHandler = new DBHandler(getSchemataENUM());
+		}
+		return m_dbHandler;
+	}
+
+	public DatabaseUpdateHandler(boolean test, SchemataENUM schemataENUMDB) {
+		this.m_test = test;
+		this.m_schemataENUM = schemataENUMDB;
+	}
+
+	public int selectAndUpdateFromDBWithFieldDataObj(String where, String database,
+			Map<String, FieldDataObj> fieldDataObjMap) {
+		StringBuilder sqlBuilder = new StringBuilder();
+		int countUpdate = 0;
+		String field = null;
+		Object data = null;
+		String fieldTyp = null;
+
+		List<String> selectUpdateFields = new ArrayList<>();
+
+		Iterator<String> fieldIT = fieldDataObjMap.keySet().iterator();
+		while (fieldIT.hasNext()) {
+			field = fieldIT.next();
+
+			selectUpdateFields.add(field);
+		}
+
+		sqlBuilder.append("select ");
+		sqlBuilder.append(SqlUtil.getSqlFields(selectUpdateFields)).append(" ");
+		sqlBuilder.append("from ").append(database).append(" ");
+		sqlBuilder.append(where);
+
+		System.out.println(sqlBuilder);
+
+		try (Connection con = getDbHandler().getConnection();
+				Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
+				ResultSet res = stmt.executeQuery(sqlBuilder.toString())) {
+			int countedSelect = res.getMetaData().getColumnCount();
+			con.setAutoCommit(false);
+			System.out.println("countedSelect " + countedSelect);
+			while (res.next() && countedSelect > 0) {
+
+				for (String updateField : selectUpdateFields) {
+					Object dataDb = res.getObject(updateField);
+
+					FieldDataObj fieldDataObj = fieldDataObjMap.get(updateField);
+					data = fieldDataObj.getData();
+					fieldTyp = data.getClass().getTypeName();
+					FieldOperator fieldOperator = fieldDataObj.getFieldOperator();
+
+					System.out.println("Update " + updateField + " Typ: " + fieldTyp + " Operator: "
+							+ fieldOperator.toString() + " Data: " + data);
+
+					switch (fieldTyp) {
+					case "java.lang.Long":
+						Long longData = Long.parseLong(data.toString());
+						Long longDataDb = Long.parseLong(dataDb.toString());
+
+						switch (fieldOperator) {
+						case OVERRIDE:
+							longDataDb = longData;
+							break;
+
+						case ADDIEREN:
+							longDataDb = longDataDb + longData;
+							break;
+
+						case SUBTRAHIEREN:
+							longDataDb = longDataDb - longData;
+							break;
+						default:
+							break;
+						}
+
+						res.updateLong(updateField, longDataDb);
+
+						break;
+
+					case "java.lang.Integer":
+						Integer intData = Integer.parseInt(data.toString());
+						Integer intDataDB = Integer.parseInt(dataDb.toString());
+
+						switch (fieldOperator) {
+						case OVERRIDE:
+							intDataDB = intData;
+							break;
+
+						case ADDIEREN:
+							intDataDB = intDataDB + intData;
+							break;
+
+						case SUBTRAHIEREN:
+							intDataDB = intDataDB - intData;
+							break;
+						default:
+							break;
+						}
+
+						res.updateInt(updateField, intDataDB);
+
+						break;
+
+					case "java.lang.Double":
+						Double doubleData = Double.parseDouble(data.toString());
+						Double doubleDataDB = Double.parseDouble(dataDb.toString());
+
+						switch (fieldOperator) {
+						case OVERRIDE:
+							doubleDataDB = doubleData;
+							break;
+
+						case ADDIEREN:
+							doubleDataDB = doubleDataDB + doubleData;
+							break;
+
+						case SUBTRAHIEREN:
+							doubleDataDB = doubleDataDB - doubleData;
+							break;
+						default:
+							break;
+						}
+
+						res.updateDouble(updateField, doubleDataDB);
+
+						break;
+
+					default: // String
+						String dataString = null;
+						switch (fieldOperator) {
+						case OVERRIDE:
+							dataString = StringUtil.safeTrimObj(data);
+
+							break;
+
+						default:
+							break;
+						}
+
+						res.updateString(updateField, dataString);
+						break;
+
+					}
+
+				}
+
+				res.updateRow();
+
+			}
+
+			con.commit();
+			countUpdate = countedSelect;
+		} catch (SQLException e) {
+			e.printStackTrace();
+		} finally {
+
+		}
+
+		return countUpdate;
+	}
+
+	public FieldDataObj checkAndCreateFieldDataObj(FieldOperator fieldOperator, Object value) {
+		FieldDataObj fieldDataObj = null;
+
+		switch (fieldOperator) {
+		case OVERRIDE:
+		case ADDIEREN:
+		case SUBTRAHIEREN:
+			fieldDataObj = new FieldDataObj(fieldOperator, value);
+			break;
+
+		default:
+			break;
+		}
+		return fieldDataObj;
+	}
+
+	public FieldDataObj checkAndCreateFieldDataObj(Object mengeOrg, Object mengeNew) {
+		String fieldTyp = null;
+		FieldOperator fieldOperator = null;
+		Object dataResult = null;
+
+		fieldTyp = mengeOrg.getClass().getTypeName();
+
+		switch (fieldTyp) {
+		case "java.lang.Long":
+			Long longDataNew = Long.parseLong(mengeNew.toString());
+			Long longDataOrg = Long.parseLong(mengeOrg.toString());
+
+			if (longDataNew > longDataOrg) {
+				fieldOperator = FieldOperator.ADDIEREN;
+			} else {
+				fieldOperator = FieldOperator.SUBTRAHIEREN;
+			}
+
+			switch (fieldOperator) {
+			case ADDIEREN:
+				dataResult = longDataNew - longDataOrg;
+				break;
+
+			case SUBTRAHIEREN:
+				dataResult = longDataOrg - longDataNew;
+				break;
+
+			default:
+				break;
+			}
+
+			break;
+
+		case "java.lang.Integer":
+			Integer intDataNew = Integer.parseInt(mengeNew.toString());
+			Integer intDataOrg = Integer.parseInt(mengeOrg.toString());
+
+			if (intDataNew > intDataOrg) {
+				fieldOperator = FieldOperator.ADDIEREN;
+			} else {
+				fieldOperator = FieldOperator.SUBTRAHIEREN;
+			}
+
+			switch (fieldOperator) {
+			case ADDIEREN:
+				dataResult = intDataNew - intDataOrg;
+				break;
+
+			case SUBTRAHIEREN:
+				dataResult = intDataOrg - intDataNew;
+				break;
+
+			default:
+				break;
+			}
+
+			break;
+
+		case "java.lang.Double":
+			Double doubleDataNew = Double.parseDouble(mengeNew.toString());
+			Double doubleDataOrg = Double.parseDouble(mengeOrg.toString());
+
+			if (doubleDataNew > doubleDataOrg) {
+				fieldOperator = FieldOperator.ADDIEREN;
+			} else {
+				fieldOperator = FieldOperator.SUBTRAHIEREN;
+			}
+
+			switch (fieldOperator) {
+			case ADDIEREN:
+				dataResult = doubleDataNew - doubleDataOrg;
+				break;
+
+			case SUBTRAHIEREN:
+				dataResult = doubleDataOrg - doubleDataNew;
+				break;
+
+			default:
+				break;
+			}
+
+			break;
+
+		default:
+			System.out.println("??? " + fieldTyp);
+			break;
+		}
+
+		FieldDataObj fieldDataObj = new FieldDataObj(fieldOperator, dataResult);
+
+		return fieldDataObj;
+	}
+
+}
diff --git a/src/main/java/de/tvo/toolset/FieldDataObj.java b/src/main/java/de/tvo/toolset/FieldDataObj.java
new file mode 100644
index 0000000..e0f1340
--- /dev/null
+++ b/src/main/java/de/tvo/toolset/FieldDataObj.java
@@ -0,0 +1,25 @@
+package de.tvo.toolset;
+
+public class FieldDataObj {
+
+	private final FieldOperator m_fieldOperator;
+	private final Object m_data;
+	
+	public FieldDataObj(FieldOperator fieldOperator, Object data) {
+		this.m_fieldOperator = fieldOperator;
+		this.m_data = data;
+	}
+
+	public FieldOperator getFieldOperator() {
+		return m_fieldOperator;
+	}
+
+	public Object getData() {
+		return m_data;
+	}
+	
+	
+	
+
+
+}
diff --git a/src/main/java/de/tvo/toolset/FieldOperator.java b/src/main/java/de/tvo/toolset/FieldOperator.java
new file mode 100644
index 0000000..333eb45
--- /dev/null
+++ b/src/main/java/de/tvo/toolset/FieldOperator.java
@@ -0,0 +1,12 @@
+package de.tvo.toolset;
+
+public enum FieldOperator {
+	
+	OVERRIDE,
+	SUBTRAHIEREN,
+	ADDIEREN,
+	
+	
+	;
+
+}
diff --git a/src/main/java/de/tvo/toolset/GeisJdbcArray.java b/src/main/java/de/tvo/toolset/GeisJdbcArray.java
new file mode 100644
index 0000000..0e59137
--- /dev/null
+++ b/src/main/java/de/tvo/toolset/GeisJdbcArray.java
@@ -0,0 +1,261 @@
+package de.tvo.toolset;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Date;
+
+public class GeisJdbcArray {
+	
+	private final Object[] jdbcResult;
+
+	public GeisJdbcArray(final Object[] jdbcResult) {
+		this.jdbcResult = jdbcResult;
+	}
+
+	/**
+	 * Returns an int representation of the Object in the index you specified in
+	 * the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1 of the value you want
+	 * @return int representation of the Object in the index you want
+	 */
+	public int getInt(final int index) {
+		if (jdbcResult[index-1] == null) {
+			return 0;
+		}
+		if (jdbcResult[index-1] instanceof Integer) {
+			return ((Integer) jdbcResult[index-1]);
+		}
+		if (jdbcResult[index-1] instanceof BigDecimal) {
+			return ((BigDecimal) jdbcResult[index-1]).intValue();
+		}
+		System.out.println("getInt - Unknown Type: " + jdbcResult[index-1].getClass().getName());
+		return 0;
+	}
+	
+	/**
+	 * Returns an int representation of the Object in the index you specified in
+	 * the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1 of the value you want
+	 * @return int representation of the Object in the index you want
+	 */
+	public BigInteger getBigInteger(final int index) {
+		if (jdbcResult[index-1] == null) {
+			return null;
+		}
+		
+		if (jdbcResult[index-1] instanceof Integer) {
+			return new BigInteger(Integer.toString(((Integer) jdbcResult[index-1])));
+		}
+		
+		if (jdbcResult[index-1] instanceof BigInteger) {
+			return ((BigInteger) jdbcResult[index-1]);
+		}
+		
+		if (jdbcResult[index-1] instanceof BigDecimal) {
+			return ((BigDecimal) jdbcResult[index-1]).toBigInteger();
+		}
+		
+
+		System.out.println("getBigInteger - Unknown Type: " + jdbcResult[index-1].getClass().getName());
+		return null;
+	}
+	
+	/**
+	 * Returns an int representation of the Object in the index you specified in
+	 * the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1 of the value you want
+	 * @return int representation of the Object in the index you want
+	 */
+	public BigDecimal getBigDecimal(final int index) {
+		if (jdbcResult[index-1] == null) {
+			return null;
+		}
+		
+		if (jdbcResult[index-1] instanceof Integer) {
+			return new BigDecimal((Integer) jdbcResult[index-1]);
+		}
+		
+		if (jdbcResult[index-1] instanceof BigDecimal) {
+			return (BigDecimal) jdbcResult[index-1];
+		}
+		
+		System.out.println("getBigInteger - Unknown Type: " + jdbcResult[index-1].getClass().getName());
+		return null;
+	}
+
+	/**
+	 * Returns an long representation of the Object in the index you specified
+	 * in the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1
+	 * @return long representation of the Object in the index you want
+	 */
+	public long getLong(final int index) {
+		if (jdbcResult[index-1] == null) {
+			return 0;
+		}
+		
+		if (jdbcResult[index-1] instanceof BigDecimal) {
+			return ((BigDecimal) jdbcResult[index-1]).longValue();
+		}
+		
+		if (jdbcResult[index-1] instanceof Long) {
+			return (Long) jdbcResult[index-1];
+		}
+		
+		System.out.println("getLong - Unknown Type: " + jdbcResult[index-1].getClass().getName());
+		return 0;
+	}
+
+	/**
+	 * Returns an short representation of the Object in the index you specified
+	 * in the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1
+	 * @return short representation of the Object in the index you want
+	 */
+	public short getShort(final int index) {
+		if (jdbcResult[index-1] == null) {
+			return 0;
+		}
+		
+		if (jdbcResult[index-1] instanceof BigDecimal) {
+			return ((BigDecimal) jdbcResult[index-1]).shortValue();
+		}
+		
+		System.out.println("getShort - Unknown Type: " + jdbcResult[index-1].getClass().getName());
+		return 0;
+	}
+
+	/**
+	 * Returns an byte representation of the Object in the index you specified
+	 * in the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1
+	 * @return byte representation of the Object in the index you want
+	 */
+	public byte getByte(final int index) {
+		if (jdbcResult[index-1] == null) {
+			return 0;
+		}
+		
+		if (jdbcResult[index-1] instanceof BigDecimal) {
+			return ((BigDecimal) jdbcResult[index-1]).byteValue();
+		}
+		
+		System.out.println("getByte - Unknown Type: " + jdbcResult[index-1].getClass().getName());
+		return 0;
+	}
+
+	/**
+	 * Returns an double representation of the Object in the index you specified
+	 * in the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1
+	 * @return double representation of the Object in the index you want
+	 */
+	public double getDouble(final int index) {
+		if (jdbcResult[index-1] == null) {
+			return 0;
+		}
+		
+		if (jdbcResult[index-1] instanceof BigDecimal) {
+			return ((BigDecimal) jdbcResult[index-1]).doubleValue();
+		}
+		
+		System.out.println("getDouble - Unknown Type: " + jdbcResult[index-1].getClass().getName());
+		return 0;
+	}
+
+	/**
+	 * Returns an float representation of the Object in the index you specified
+	 * in the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1
+	 * @return float representation of the Object in the index you want
+	 */
+	public float getFloat(final int index) {
+		if (jdbcResult[index-1] == null) {
+			return 0;
+		}
+		
+		if (jdbcResult[index-1] instanceof BigDecimal) {
+			return ((BigDecimal) jdbcResult[index-1]).floatValue();
+		}
+		
+		System.out.println("getFloat - Unknown Type: " + jdbcResult[index-1].getClass().getName());
+		return 0;
+	}
+
+	/**
+	 * Returns an String representation of the Object in the index you specified
+	 * in the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1
+	 * @return String representation of the Object in the index you want
+	 */
+	public String getString(final int index) {
+		if (jdbcResult[index-1] == null) {
+			return null;
+		}
+		
+		if (jdbcResult[index-1] instanceof String) {
+			return (String) jdbcResult[index-1];
+		}
+		
+		return jdbcResult[index-1].toString();
+	}
+
+	public boolean getBoolean(final int index) {
+		if (jdbcResult[index-1] == null) {
+			return false;
+		}
+		
+		if (jdbcResult[index-1] instanceof Boolean) {
+			return (Boolean) jdbcResult[index-1];
+		}
+		
+		if (jdbcResult[index-1] instanceof BigDecimal) {
+			return ((BigDecimal) jdbcResult[index-1]).equals(BigDecimal.ONE);
+		}
+		
+		return false;
+	}
+	
+	/**
+	 * Returns an Date representation of the Object in the index you specified
+	 * in the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1
+	 * @return Date representation of the Object in the index you want
+	 */
+	public Date getDate(final int index) {
+		return (Date) jdbcResult[index-1];
+	}
+
+	/**
+	 * Returns an plain representation of the Object in the index you specified
+	 * in the parameters
+	 * 
+	 * @param Index
+	 *            index of the value you want. Careful, first Index starts with 1
+	 * @return plain representation of the Object in the index you want
+	 */
+	public Object get(final int index) {
+		return jdbcResult[index-1];
+	}
+
+}
diff --git a/src/main/java/de/tvo/toolset/HibernateUtils.java b/src/main/java/de/tvo/toolset/HibernateUtils.java
new file mode 100644
index 0000000..3333a4e
--- /dev/null
+++ b/src/main/java/de/tvo/toolset/HibernateUtils.java
@@ -0,0 +1,52 @@
+package de.tvo.toolset;
+
+import java.lang.reflect.Field;
+
+import de.tvo.reflection.MyObject;
+
+public class HibernateUtils {
+
+	public HibernateUtils() {
+
+	}
+	
+	@SuppressWarnings("rawtypes")
+	public static Object copyFieldsIntoObject(Object dataObj, Class classtyp, String startWith) throws Exception {
+		Object resultObj = classtyp.newInstance();
+		MyObject myObjectSource = new MyObject(dataObj);
+		MyObject myObjectTarget = new MyObject(resultObj);
+		Field[] fields = classtyp.getDeclaredFields();
+		
+		for (Field field : fields) {
+			String fieldname = field.getName();
+			Object value = myObjectSource.get(fieldname);
+			//System.out.println(fieldname + " - " + value);
+			
+			if (fieldname.startsWith(startWith)) {
+				myObjectTarget.set(fieldname, value);
+			}
+		}
+		return myObjectTarget.getObject();
+	}
+	
+	public static void main(String[] args) {
+		try {
+//			Class class1 = Class.forName(TestObj.class.getName());
+//			Object object = class1.newInstance();
+//			
+//			Field[] fields = object.getClass().getDeclaredFields();
+//			
+//			System.out.println(fields);
+//			
+//			for (Field field : fields) {
+//				System.out.println(field.getName());
+//			}
+//			
+//			System.out.println(object.getClass().getName());
+		} catch (Exception e) {
+			// TODO: handle exception
+		}
+		
+	}
+
+}