/*********************************************************************************
* The contents of this file are subject to the Common Public Attribution
* License Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.openemm.org/cpal1.html. The License is based on the Mozilla
* Public License Version 1.1 but Sections 14 and 15 have been added to cover
* use of software over a computer network and provide for limited attribution
* for the Original Developer. In addition, Exhibit A has been modified to be
* consistent with Exhibit B.
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
*
* The Original Code is OpenEMM.
* The Original Developer is the Initial Developer.
* The Initial Developer of the Original Code is AGNITAS AG. All portions of
* the code written by AGNITAS AG are Copyright (c) 2007 AGNITAS AG. All Rights
* Reserved.
*
* Contributor(s): AGNITAS AG.
********************************************************************************/
package org.agnitas.util;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.UnsupportedEncodingException;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLEncoder;
import java.security.SecureRandom;
import java.sql.Blob;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Enumeration;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;
import java.util.ResourceBundle;
import java.util.Set;
import java.util.TimeZone;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import javax.mail.Message;
import javax.mail.Multipart;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import javax.servlet.ServletContext;
import javax.servlet.ServletRequest;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.servlet.jsp.PageContext;
import javax.sql.DataSource;
import org.agnitas.backend.StringOps;
import org.agnitas.beans.Admin;
import org.agnitas.beans.Company;
import org.agnitas.dao.CompanyDao;
import org.apache.axis.encoding.Base64;
import org.apache.commons.collections.map.CaseInsensitiveMap;
import org.apache.commons.configuration.Configuration;
import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.apache.commons.dbcp.BasicDataSource;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.mail.ByteArrayDataSource;
import org.apache.commons.mail.MultiPartEmail;
import org.apache.commons.validator.EmailValidator;
import org.apache.log4j.Logger;
import org.apache.velocity.exception.MethodInvocationException;
import org.apache.velocity.exception.ParseErrorException;
import org.apache.velocity.exception.ResourceNotFoundException;
import org.hibernate.SessionFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceUtils;
import bsh.Interpreter;
import bsh.NameSpace;
/**
*
* @author mhe, Nicole Serek
*/
public class AgnUtils {
private static final transient Logger logger = Logger.getLogger(AgnUtils.class);
private static Configuration config;
public static final String DEFAULT_MAILING_HTML_DYNNAME = "HTML-Version";
public static final String DEFAULT_MAILING_MHTML_DYNNAME = "M-HTML-Version";
public static final String DEFAULT_MAILING_TEXT_DYNNAME = "Text";
/**
* Getter for property currentVersion
* @return version the current version
*/
public static String getCurrentVersion() {
return isOracleDB() ? "7.0" : "2013";
}
/**
* constant
*/
protected static long lastErrorMailingSent=0;
/*
* This method is deprecated because we lose the logger hierarchy.
*
* It's better, to add this line to each class that requires logging:
* private static final transient Logger logger = Logger.getLogger(<name of the class>.class);
*/
@Deprecated
public static Logger logger() {
return Logger.getLogger("org.agnitas");
}
public static Logger userlogger() {
return Logger.getLogger("org.agnitas.userlogs");
}
/**
* Getter for property stackTrace.
*
* @return Value of property stackTrace.
*/
public static String getStackTrace(Exception e) {
String trace="";
StackTraceElement[] st=e.getStackTrace();
for(int c=0; c < st.length && c < 20; c++) {
trace+=st[c].toString()+"\n";
}
return trace;
}
/**
* Checks whether we are running on oracle
*/
public static boolean isOracleDB() {
org.hibernate.dialect.Dialect dialect=AgnUtils.getHibernateDialect();
if(dialect instanceof org.hibernate.dialect.Oracle9Dialect ||
dialect instanceof org.hibernate.dialect.OracleDialect) {
return true;
}
return false;
}
/**
* Checks whether we are running on mysql
*/
public static boolean isMySQLDB() {
org.hibernate.dialect.Dialect dialect=AgnUtils.getHibernateDialect();
if(dialect instanceof org.hibernate.dialect.MySQLDialect) {
return true;
}
return false;
}
/**
* returns a date string
*/
public static String sqlDateString(String field, String format) {
String ret="";
if(isMySQLDB()) {
format=format.replaceAll("yyyy", "%Y");
format=format.replaceAll("yy", "%y");
format=format.replaceAll("mm", "%m");
format=format.replaceAll("dd", "%d");
ret="date_format("+field+", '"+format+"')";
} else {
ret="to_char("+field+", '"+format+"')";
}
return ret;
}
/**
* returns the name for the change date field
*/
public static String changeDateName() {
if (isOracleDB()) {
return "TIMESTAMP";
} else {
if (isProjectEMM()) {
return "TIMESTAMP";
} else {
return "change_date";
}
}
}
// only return true every 30 Seconds
public static synchronized boolean sendErrorMailingInterval() {
boolean result=false;
if(System.currentTimeMillis()-AgnUtils.lastErrorMailingSent>600000) {
AgnUtils.lastErrorMailingSent=System.currentTimeMillis();
result=true;
}
return result;
}
/**
* Getter for property jdbcTemplate.
*
* @return Value of property jdbcTemplate.
*
* @Deprecated
*/
public static synchronized JdbcTemplate getJdbcTemplate(org.springframework.context.ApplicationContext aContext) {
return new JdbcTemplate((DataSource) aContext.getBean("dataSource"));
}
/**
* Getter for property dataSource.
*
* @return Value of property dataSource.
*/
public static synchronized DataSource retrieveDataSource(ServletContext aContext) {
BasicDataSource aSource=null;
aSource=(BasicDataSource)org.springframework.web.context.support.WebApplicationContextUtils.getWebApplicationContext(aContext).getBean("dataSource");
return aSource;
}
/**
* Getter for property sessionFactory.
*
* @return Value of property sessionFactory.
*/
public static synchronized SessionFactory retrieveSessionFactory(ServletContext aContext) {
SessionFactory aSource=null;
aSource=(SessionFactory)org.springframework.web.context.support.WebApplicationContextUtils.getWebApplicationContext(aContext).getBean("sessionFactory");
return aSource;
}
/**
* Sends an email in the correspondent type.
*/
public static boolean sendEmail(String from_adr, String to_adrList, String subject, String body_text, String body_html, int mailtype, String charset) {
return sendEmail(from_adr, to_adrList, null, subject, body_text, body_html, mailtype, charset);
}
/**
* Sends an email in the correspondent type.
*/
public static boolean sendEmail(String from_adr, String to_adrList, String cc_adrList, String subject, String body_text, String body_html, int mailtype, String charset) {
try {
// create some properties and get the default Session
Properties props = new Properties();
props.put("system.mail.host", getSmtpMailRelayHostname());
Session session = Session.getDefaultInstance(props, null);
// session.setDebug(debug);
// create a message
MimeMessage msg = new MimeMessage(session);
msg.setFrom(new InternetAddress(from_adr));
msg.setSubject(subject, charset);
msg.setSentDate(new Date());
// Set to-recipient email addresses
InternetAddress[] toAddresses = getEmailAddressesFromList(to_adrList);
if (toAddresses != null && toAddresses.length > 0) {
msg.setRecipients(Message.RecipientType.TO, toAddresses);
}
// Set cc-recipient email addresses
InternetAddress[] ccAddresses = getEmailAddressesFromList(cc_adrList);
if (ccAddresses != null && ccAddresses.length > 0) {
msg.setRecipients(Message.RecipientType.CC, ccAddresses);
}
switch (mailtype) {
case 0:
msg.setText(body_text, charset);
break;
case 1:
Multipart mp = new MimeMultipart("alternative");
MimeBodyPart mbp = new MimeBodyPart();
mbp.setText(body_text, charset);
mp.addBodyPart(mbp);
mbp = new MimeBodyPart();
mbp.setContent(body_html, "text/html; charset=" + charset);
mp.addBodyPart(mbp);
msg.setContent(mp);
break;
}
Transport.send(msg);
} catch (Exception e) {
logger.error("sendEmail: " + e);
logger.error(AgnUtils.getStackTrace(e));
return false;
}
return true;
}
/** Log an Exception
* Logs the given comment, exception text and stack trace to error log
* and sends an email to the address taken from mailaddress.error
* property.
*
* @param comment Text that is added before the exception.
* @param e The exception to log.
* @return true if all went ok.
*/
public static boolean sendExceptionMail(String comment, Exception e) {
String targetMail = AgnUtils.getDefaultValue("mailaddress.error");
String senderAddress = AgnUtils.getDefaultValue("mailaddress.sender");
String message = "";
if (comment != null) {
message = comment + "\n";
}
message += "Exception: " + e + "\n";
message += AgnUtils.getStackTrace(e);
logger.error(message);
if (targetMail != null && senderAddress != null) {
try {
return sendEmail(senderAddress, targetMail, null, "EMM Fehler", message, "", 0, "utf-8");
} catch (Exception me) {
logger.error("Exception: " + e);
logger.error(AgnUtils.getStackTrace(e));
return false;
}
}
return true;
}
/**
* Sends the attachment of an email.
*/
public static boolean sendEmailAttachment(String from, String to_adrList, String cc_adrList, String subject, String txt, byte[] att_data, String att_name, String att_type) {
boolean result = true;
try {
// Create the email message
MultiPartEmail email = new MultiPartEmail();
email.setCharset("UTF-8");
email.setHostName(getSmtpMailRelayHostname());
email.setFrom(from);
email.setSubject(subject);
email.setMsg(txt);
// bounces and reply forwarded to assistance@agnitas.de
email.addReplyTo("assistance@agnitas.de");
email.setBounceAddress("assistance@agnitas.de");
// Set to-recipient email addresses
InternetAddress[] toAddresses = getEmailAddressesFromList(to_adrList);
if (toAddresses != null && toAddresses.length > 0) {
for (InternetAddress singleAdr : toAddresses) {
email.addTo(singleAdr.getAddress());
}
}
// Set cc-recipient email addresses
InternetAddress[] ccAddresses = getEmailAddressesFromList(cc_adrList);
if (ccAddresses != null && ccAddresses.length > 0) {
for (InternetAddress singleAdr : ccAddresses) {
email.addCc(singleAdr.getAddress());
}
}
// Create and add the attachment
ByteArrayDataSource attachment = new ByteArrayDataSource(att_data, att_type);
email.attach(attachment, att_name, "EMM-Report");
// send the email
email.send();
} catch (Exception e) {
logger.error("sendEmailAttachment: " + e.getMessage(), e);
result = false;
}
return result;
}
/**
* Reads a file.
*/
public static String readFile(String path) {
String value=null;
try {
File aFile=new File(path);
byte[] b=new byte[(int)aFile.length()];
DataInputStream in=new DataInputStream(new FileInputStream(aFile));
in.readFully(b);
value=new String(b);
in.close();
} catch (Exception e) {
value=null;
}
return value;
}
/**
* Checks the email adress
*/
public static boolean checkEmailAdress(String email){
boolean value=false;
try {
if(email.length() < 3 || email.indexOf("@")==-1) {
value=false;
} else {
value=true;
}
} catch (Exception e) {
value=false;
}
return value;
}
/**
* Getter for property parameterMap.
*
* @return Value of property parameterMap.
*/
public static Map<String, String> getRequestParameterMap(ServletRequest req) {
Map<String, String> parameterMap = new HashMap<String, String>();
@SuppressWarnings("unchecked")
Enumeration<String> e = req.getParameterNames();
while (e.hasMoreElements()) {
String parameterName = e.nextElement();
String paremeterValue = req.getParameter(parameterName);
parameterMap.put(parameterName, paremeterValue);
}
return parameterMap;
}
/**
* Getter for property defaultIntValue.
*
* @return Value of property defaultIntValue.
*/
public static int getDefaultIntValue(String key) {
int result=0;
String resultString=AgnUtils.getDefaultValue(key);
if(resultString!=null) {
try {
result=Integer.parseInt(resultString);
} catch (Exception e) {
// do nothing
}
}
return result;
}
/**
* Getter for property defaultValue.
*
* @return Value of property defaultValue.
*/
public static String getDefaultValue(String key) {
ResourceBundle defaults=null;
String result=null;
try {
defaults=ResourceBundle.getBundle("emm");
} catch (Exception e) {
logger.error("getDefaultValue: "+e.getMessage());
return null;
}
try {
result=defaults.getString(key);
} catch (Exception e) {
logger.error("getDefaultValue: "+e.getMessage());
result=null;
}
return result;
}
/**
* Getter for property hibernateDialect.
*
* @return Value of property hibernateDialect.
*/
public static org.hibernate.dialect.Dialect getHibernateDialect() {
return org.hibernate.dialect.DialectFactory.buildDialect(AgnUtils.getDefaultValue("jdbc.dialect"));
}
public static boolean isProjectEMM() {
String sysName = AgnUtils.getDefaultValue("system.type");
if (sysName != null && sysName.toLowerCase().equals("emm")) {
return true;
} else {
return false;
}
}
public static boolean isProjectOpenEMM() {
String sysName = AgnUtils.getDefaultValue("system.type");
if (sysName.toLowerCase().equals("openemm")) {
return true;
} else {
return false;
}
}
/**
* Getter for property SQLCurrentTimestamp.
*
* @return Value of property SQLCurrentTimestamp.
*/
public static String getSQLCurrentTimestamp() {
return org.hibernate.dialect.DialectFactory.buildDialect(AgnUtils.getDefaultValue("jdbc.dialect")).getCurrentTimestampSQLFunctionName();
}
public static String getSQLCurrentTimestampName() {
if (isOracleDB()) {
return "sysdate";
} else {
return getSQLCurrentTimestamp ();
}
}
/**
* Matches the target with the collection.
* You shouldn't use this method anymore :
* 1st it's quite slow
* 2nd it seems to have problems recognizing blacklist patterns with containing the '%'-sign
* Use Blacklist instead
* @deprecated
*/
public static boolean matchCollection(String target, Collection<String> collection) {
if (target == null || collection == null) {
return false;
}
try {
for(String mask : collection) {
if (AgnUtils.match(mask, target)) {
return true;
}
}
} catch (Exception e) {
}
return false;
}
public static boolean match_old(String mask, String target) {
// ported almost verbatim from rpb's ages old Turbo Pascal 1.0 routine
//
// Compare two strings which may contain the DOS wildcard characters * and ?
// and return a boolean result indicating their "equivalence".
// e.g. WCMatcher.match("*.java", "WCMatcher.java") will return true as
// will WCMatcher.match("w?mat*", "WCMatcher.java"). On the other hand,
// WCMatcher.match("*.java", "WCMatcher.class") will return false (as you
// would expect). Note that the name/extension separator (i.e. the period)
// is treated like any other character in the mask or target when compared
// with one of the wildcard characters. "*" will match "hosts" or "hosts."
// or "java.exe" BUT "*." will only match a target that ends in ".something"
// Clear as mud? Try it ... it's fairly intuitive after observing a few
// examples.
//
// Most usage will involve a filename mask (e.g. *.java) being
// compared with some filename (e.g. WCMatcher.java). However,
// either mask or target or both may contain DOS wildcard characters
// and this routine "should" provide an arguably correct result
//
// Note also that this method is case insensitive! i.e. "rpb" == "RPB"
// (as is DOS). A future todo item might be to optionally allow a
// case sensitive comparison.
//
// caution - it seems to work
// if anything is null, no match
if(mask==null || target==null) {
return false;
}
int p1 = 0; // used as character index into mask
int p2 = 0; // used as character index into target
boolean matched = true; // Assume true to begin.
// A warning about side effects here: an initial
// value of false won't work!! I've just been too
// lazy to eliminate the assumption (the routine
// was written this way back in the early 80's)
if ((mask.length() == 0) && (target.length() == 0)) {
matched = true;
} else {
if (mask.length() == 0) {
if (target.charAt(0) == '%') {
matched = true;
} else {
matched = false;
}
} else {
if (target.length() == 0) {
if (mask.charAt(0) == '%') {
matched = true;
} else {
matched = false;
}
}
}
}
while ((matched) && (p1 < mask.length()) && (p2 < target.length())) {
if ((mask.charAt(p1) == '_') || (target.charAt(p2) == '_')) {
p1++; p2++;
} else {
if ( mask.charAt(p1) == '%' ) {
p1++;
if (p1 < mask.length()) {
while ((p2 < target.length())
&& (!match( mask.substring(p1,
mask.length()),
target.substring(p2,
target.length())))) {
p2++;
}
if (p2 >= target.length()) {
matched = false;
} else {
p1 = mask.length();
p2 = target.length();
}
} else {
p2 = target.length();
}
} else {
if (target.charAt(p2) == '%') {
p2++;
if (p2 < target.length()) {
while ( (p1 < mask.length())
&& (!match( mask.substring(p1,
mask.length()),
target.substring(p2,
target.length()))) ) {
p1++;
}
if (p1 >= mask.length()) {
matched = false;
} else {
p1 = mask.length();
p2 = target.length();
}
} else {
p1 = mask.length();
}
} else {
if (mask.toLowerCase().charAt(p1) == target.toLowerCase().charAt(p2)) {
p1++;
p2++;
} else {
matched = false;
}
}
}
}
}//wend
if (p1 >= mask.length()) {
while ( (p2 < target.length()) && (target.charAt(p2) == '%') ) {
p2++;
}
if (p2 < target.length()) {
matched = false;
}
}
if (p2 >= target.length()) {
while ( (p1 < mask.length()) && (mask.charAt(p1) == '%')) {
p1++;
}
if (p1 < mask.length()) {
matched = false;
}
}
return matched;
}
public static boolean matchOneway(String mask, String target) {
// like match, but allows only pattern in mask, not in target
// everything else is a shameless copy of match
// if anything is null, no match
if(mask == null || target == null) {
return false;
}
int p1 = 0; // used as character index into mask
int p2 = 0; // used as character index into target
boolean matched = true; // Assume true to begin.
// A warning about side effects here: an initial
// value of false won't work!! I've just been too
// lazy to eliminate the assumption (the routine
// was written this way back in the early 80's)
if ((mask.length() == 0) && (target.length() == 0)) {
matched = true;
} else {
if (target.length() == 0) {
if (mask.charAt(0) == '%') {
matched = true;
} else {
matched = false;
}
}
}
while ((matched) && (p1 < mask.length()) && (p2 < target.length())) {
if ((mask.charAt(p1) == '_')) {
p1++; p2++;
} else {
if (mask.charAt(p1) == '%') {
p1++;
if (p1 < mask.length()) {
while ((p2 < target.length())
&& (!match( mask.substring(p1,
mask.length()),
target.substring(p2,
target.length())))) {
p2++;
}
if (p2 >= target.length()) {
matched = false;
} else {
p1 = mask.length();
p2 = target.length();
}
} else {
p2 = target.length();
}
} else {
if (mask.toLowerCase().charAt(p1) == target.toLowerCase().charAt(p2)) {
p1++;
p2++;
} else {
matched = false;
}
}
}
}//wend
if (p2 >= target.length()) {
while ((p1 < mask.length()) && (mask.charAt(p1) == '%')) {
p1++;
}
if (p1 < mask.length()) {
matched = false;
}
} else
matched = false;
return matched;
}
/**
* Returns a date format.
*/
public static String formatDate(Date aDate, String pattern) {
if(aDate == null) {
return null;
}
SimpleDateFormat aFormat = new SimpleDateFormat(pattern);
return aFormat.format(aDate);
}
/**
* Getter for the system date.
*
* @return Value of the system date.
*/
public static Date getSysdate(String sysdate) {
int value = 0;
char operator;
GregorianCalendar result = new GregorianCalendar();
if( sysdate.contains("now()")) {
if( "now()".equals(sysdate)) {
return result.getTime();
}
// handle date_add/ date_sub
if( sysdate.startsWith("date_add") || sysdate.startsWith("date_sub") ) {
value = extractDayFromSysdate(sysdate);
if( sysdate.startsWith("date_add")) {
result.add(GregorianCalendar.DAY_OF_MONTH, value);
}
if( sysdate.startsWith("date_sub")) {
result.add(GregorianCalendar.DAY_OF_MONTH, value*(-1));
}
}
return result.getTime();
}
if(!sysdate.equals("sysdate")) { // +/- <days>
operator = sysdate.charAt(7);
try {
value = Integer.parseInt(sysdate.substring(8));
} catch (Exception e) {
value = 0;
}
switch(operator) {
case '+':
result.add(GregorianCalendar.DAY_OF_MONTH, value);
break;
case '-':
result.add(GregorianCalendar.DAY_OF_MONTH, value*(-1));
break;
}
}
return result.getTime();
}
/**
* compares Strings
* modes:
* 0 == test for equal
* 1 == test for not equal
* 2 == test for a greater b
* 3 == test for a smaller b
*/
public static boolean compareString(String a, String b, int mode) {
boolean result=false;
// if both strings are null, we have a match.
if(a == null && b == null) {
return true;
}
// if one string is null, no match
if(a == null || b == null) {
return false;
}
int stringres = a.compareTo(b);
switch(mode) {
case 0:
if(stringres == 0) {
result = true;
}
break;
case 1:
if(stringres !=0 ) {
result = true;
}
break;
case 2:
if(stringres > 0) {
result = true;
}
break;
case 3:
if(stringres < 0) {
result = true;
}
break;
}
return result;
}
public static String toLowerCase(String source) {
if(source == null) {
return null;
}
return source.toLowerCase();
}
/**
* Getter for property reqParameters.
*
* @return Value of property reqParameters.
*/
public static HashMap<String, String> getReqParameters(HttpServletRequest req) {
HashMap<String, String> params = new HashMap<String, String>();
String parName = null;
@SuppressWarnings("unchecked")
Enumeration<String> aEnum1 = req.getParameterNames();
while (aEnum1.hasMoreElements()) {
parName = aEnum1.nextElement();
if (parName.startsWith("__AGN_DEFAULT_") && parName.length() > 14) {
parName = parName.substring(14);
params.put(parName, req.getParameter("__AGN_DEFAULT_" + parName));
}
}
@SuppressWarnings("unchecked")
Enumeration<String> aEnum2 = req.getParameterNames();
while (aEnum2.hasMoreElements()) {
parName = (String) aEnum2.nextElement();
params.put(parName, req.getParameter(parName));
}
if (req.getQueryString() != null) {
params.put("agnQueryString", req.getQueryString());
}
return params;
}
/**
* Checkes the permissions.
*/
public static boolean allowed(String id, HttpServletRequest req) {
Admin admin = AgnUtils.getAdmin(req);
if (admin == null) {
return false; // Nothing allowed if there is no Session
}
Set<String> permission = admin.getAdminPermissions();
if (permission != null && permission.contains(id)) {
return true; // Allowed for user.
}
permission = admin.getGroup().getGroupPermissions();
if (permission != null && permission.contains(id)) {
return true; // Allowed for group.
}
return false;
}
/**
* Gets the used language.
*/
public static Locale buildLocale(String language) {
Locale aLoc = null;
if(language != null) {
int aPos = language.indexOf('_');
String lang = language.substring(0,aPos);
String country = language.substring(aPos+1);
aLoc = new Locale(lang, country);
}
return aLoc;
}
/**
* Getter for property firstResult.
*
* @return Value of property firstResult.
*/
public static Object getFirstResult(List<Object> aList) {
Object result = null;
if (aList != null && aList.size() > 0) {
result = aList.get(0);
}
return result;
}
/**
* Prepares a string ready for saving.
*/
public static String propertySaveString(String input) {
if(input == null) {
input = "";
}
input = StringUtils.replace(input, "=", "\\=");
input = StringUtils.replace(input, "\"", "\\\"");
input = StringUtils.replace(input, ",", "\\,");
return input;
}
/**
* Search for parameters.
*/
public static String findParam(String paramName, String paramList) {
String result = null;
try {
if(paramName != null) {
int posA = paramList.indexOf(paramName+"=\"");
if(posA != -1) {
int posB = paramList.indexOf("\",", posA);
if(posB != -1) {
result = paramList.substring(posA+paramName.length()+2, posB);
result = StringUtils.replace(result, "\\=", "=");
result = StringUtils.replace(result, "\\\"", "\"");
result = StringUtils.replace(result, "\\,", ",");
}
}
}
} catch (Exception e) {
logger.error("findParam: "+e.getMessage());
}
return result;
}
/**
* Getter for property companyID.
*
* @return Value of property companyID.
*/
public static int getCompanyID(HttpServletRequest req) {
try {
Company company = AgnUtils.getCompany(req);
if (company == null) {
logger.error("AgnUtils: getCompanyID - no companyID found (company is null)");
return 0;
} else {
return company.getId();
}
} catch (Exception e) {
logger.error("AgnUtils: getCompanyID - no companyID found for request", e);
return 0;
}
}
public static Admin getAdmin(HttpServletRequest request) {
try {
HttpSession session = request.getSession();
if (session == null) {
logger.error("no request session found for getAdmin");
return null;
} else {
Admin admin = (Admin) session.getAttribute("emm.admin");
if (admin == null) {
logger.error("no admin found in request session data");
return null;
} else {
return admin;
}
}
} catch (Exception e) {
logger.error("no admin found for request", e);
return null;
}
}
public static void setAdmin(HttpServletRequest request, Admin admin) {
try {
HttpSession session = request.getSession();
if (session != null)
session.setAttribute("emm.admin", admin);
else
logger.error("no session found for setting admin data");
} catch (Exception e) {
logger.error("error while setting admin data in session");
}
}
public static Admin getAdmin(PageContext pageContext) {
try {
HttpSession session = pageContext.getSession();
if (session == null) {
logger.error("no pageContext data found for getAdmin");
return null;
} else {
Admin admin = (Admin) session.getAttribute("emm.admin");
if (admin == null) {
logger.error("no admin found in pageContext data");
return null;
} else {
return admin;
}
}
} catch (Exception e) {
logger.error("no admin found for pageContext", e);
return null;
}
}
public static boolean isUserLoggedIn(HttpServletRequest request) {
return getAdmin(request) != null;
}
/**
* Getter for property timeZone.
*
* @return Value of property timeZone.
*/
public static TimeZone getTimeZone(HttpServletRequest req) {
TimeZone tz=null;
try {
tz=TimeZone.getTimeZone(AgnUtils.getAdmin(req).getAdminTimezone());
} catch (Exception e) {
logger.error("no admin");
tz=null;
}
return tz;
}
/**
* Getter for property company.
*
* @return Value of property company.
*/
public static Company getCompany(HttpServletRequest req) {
try {
Admin admin = AgnUtils.getAdmin(req);
if (admin == null) {
logger.error("AgnUtils: getCompany: no admin found in request");
return null;
} else {
Company company = admin.getCompany();
if (company == null) {
logger.error("AgnUtils: getCompany: no company found for admin " + admin.getAdminID() + "(" + admin.getCompanyID() + ")");
return null;
} else {
return company;
}
}
} catch (Exception e) {
logger.error("AgnUtils: getCompany: no company found for the admin from request", e);
return null;
}
}
/*
* Checks if date is in future. It is allowed to specify a date that is up to 5 minutes in the past.
*
* @param date Checked date.
*/
/*
public static boolean isDateInFuture(Date date) {
// Create the calendar object for comparison
GregorianCalendar now = new GregorianCalendar();
GregorianCalendar calendarToTest = new GregorianCalendar();
// Set the time of the test-calendar
calendarToTest.setTime(date);
// Move it 5 minutes into future, so we get a 5 minute fairness period
calendarToTest.add(GregorianCalendar.MINUTE, 5);
// Do the hard work!
return now.before(calendarToTest);
}
*/
/**
* Checks if date is in future.
*
* @param aDate Checked date.
*/
public static boolean isDateInFuture(Date aDate) {
boolean result=false;
GregorianCalendar aktCal=new GregorianCalendar();
GregorianCalendar tmpCal=new GregorianCalendar();
tmpCal.setTime(aDate);
aktCal.add(GregorianCalendar.MINUTE, 5); // look five minutes in future ;-)
if(aktCal.before(tmpCal)) {
result=true;
}
return result;
}
/**
* Getter for property bshInterpreter.
*
* @return Value of property bshInterpreter.
*/
public static Interpreter getBshInterpreter(int cID, int customerID, ApplicationContext con) {
DataSource ds=(DataSource)con.getBean("dataSource");
Interpreter aBsh=new Interpreter();
NameSpace aNameSpace=aBsh.getNameSpace();
aNameSpace.importClass("org.agnitas.util.AgnUtils");
String sqlStatement="select * from customer_"+cID+"_tbl cust where cust.customer_id="+customerID;
Connection dbCon=DataSourceUtils.getConnection(ds);
try {
Statement stmt=dbCon.createStatement();
ResultSet rset=stmt.executeQuery(sqlStatement);
ResultSetMetaData aMeta=rset.getMetaData();
if(rset.next()) {
for(int i=1; i<=aMeta.getColumnCount(); i++) {
switch(aMeta.getColumnType(i)) {
case java.sql.Types.BIGINT:
case java.sql.Types.INTEGER:
case java.sql.Types.NUMERIC:
case java.sql.Types.SMALLINT:
case java.sql.Types.TINYINT:
if(rset.getObject(i)!=null) {
aNameSpace.setTypedVariable(aMeta.getColumnName(i), java.lang.Integer.class, new Integer(rset.getInt(i)), null);
} else {
aNameSpace.setTypedVariable(aMeta.getColumnName(i), java.lang.Integer.class, null, null);
}
break;
case java.sql.Types.DECIMAL:
case java.sql.Types.DOUBLE:
case java.sql.Types.FLOAT:
if(rset.getObject(i)!=null) {
aNameSpace.setTypedVariable(aMeta.getColumnName(i), java.lang.Double.class, new Double(rset.getDouble(i)), null);
} else {
aNameSpace.setTypedVariable(aMeta.getColumnName(i), java.lang.Double.class, null, null);
}
break;
case java.sql.Types.CHAR:
case java.sql.Types.LONGVARCHAR:
case java.sql.Types.VARCHAR:
aNameSpace.setTypedVariable(aMeta.getColumnName(i), java.lang.String.class, rset.getString(i), null);
break;
case java.sql.Types.DATE:
case java.sql.Types.TIME:
case java.sql.Types.TIMESTAMP:
aNameSpace.setTypedVariable(aMeta.getColumnName(i), java.util.Date.class, rset.getTimestamp(i), null);
break;
default:
logger.error("Ignoring: "+aMeta.getColumnName(i));
}
}
}
rset.close();
stmt.close();
// add virtual column "sysdate"
aNameSpace.setTypedVariable(AgnUtils.getHibernateDialect().getCurrentTimestampSQLFunctionName(), Date.class, new Date(), null);
} catch (Exception e) {
sendExceptionMail("Sql: " + sqlStatement, e);
logger.error("getBshInterpreter: "+e.getMessage());
aBsh=null;
}
DataSourceUtils.releaseConnection(dbCon, ds);
return aBsh;
}
public static byte[] BlobToByte(Blob fromBlob) {
if (fromBlob == null) {
return null;
} else {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
logger.info("Writing Blob");
try {
return toByteArrayImpl(fromBlob, baos);
} catch (SQLException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (baos != null) {
try {
baos.close();
} catch (IOException ex) {
logger.error( "BlobToByte", ex);
}
}
}
}
}
private static byte[] toByteArrayImpl(Blob fromBlob, ByteArrayOutputStream baos)
throws SQLException, IOException {
byte[] buf = new byte[4000];
InputStream is = fromBlob.getBinaryStream();
try {
for (;;) {
int dataSize = is.read(buf);
if (dataSize == -1)
break;
baos.write(buf, 0, dataSize);
}
} finally {
if (is != null) {
try {
is.close();
} catch (IOException ex) {
logger.error( "toByteArrayImpl", ex);
}
}
}
return baos.toByteArray();
}
public static String getHelpURL(HttpServletRequest req) {
String base="help_"+getAdmin(req).getAdminLang().toLowerCase();
String name=req.getServletPath();
String path=null;
File rel=null;
File file=null;
name=name.substring(0, name.length()-4);
rel=new File(name);
while(rel.getParent() != null) {
path=req.getSession().getServletContext().getRealPath(base+rel.getAbsoluteFile()+".htm");
file=new File(path);
if(file.exists()) {
try {
return base+rel.getCanonicalFile()+".htm";
} catch(Exception e) {
logger.error( "getHelpURL", e);
}
}
rel=new File(rel.getParent());
}
return base+"/index.jsp";
}
public static Company getCompanyCache(int companyID, ApplicationContext con) {
@SuppressWarnings("unchecked")
TimeoutLRUMap<Integer, Company> companyCache = (TimeoutLRUMap<Integer, Company>) con.getBean("companyCache");
CompanyDao cDao = (CompanyDao)con.getBean("CompanyDao");
Company aCompany = null;
aCompany = (Company)companyCache.get(companyID);
if(aCompany == null) {
aCompany = cDao.getCompany(companyID);
if(aCompany != null) {
companyCache.put(companyID, aCompany);
}
}
return aCompany;
}
public static boolean match(String mask, String target) {
// if anything is null, no match
if(mask==null || target==null) {
return false;
}
mask = mask.toLowerCase();
target = target.toLowerCase();
if(mask.compareTo(target) == 0) {
return true; //match!
}
boolean matched = true;
if(mask.indexOf('%') >= 0 || mask.indexOf('_') >= 0) {
matched = rmatch(mask, target); //find match incl wildcards
} else {
matched = false; //no wildcard - no match
}
return matched;
}
public static boolean rmatch(String mask, String target) {
int moreCharacters = mask.indexOf('%');
int oneCharacter = mask.indexOf('_');
int pattern = -1;
if(moreCharacters >= 0) {
pattern = moreCharacters;
}
if(oneCharacter >= 0 && (oneCharacter < pattern || pattern < 0)) {
pattern = oneCharacter;
}
if(pattern == -1) {
if(mask.compareTo(target) == 0) {
return true; //match!
}
return false;
}
if(!mask.regionMatches(0, target, 0, pattern)) {
return false;
}
if(pattern == oneCharacter) {
// '_' found
return rmatch(mask.substring(pattern + 1), target.substring(pattern + 1));
}
String after = mask.substring(moreCharacters + 1, mask.length());
for(int c = pattern; c < target.length(); c++) {
if(rmatch(after, target.substring(c, target.length()))) {
return true;
}
}
return false;
}
public static String getEMMProperty(String propertyName) {
config = getPropertiesConfiguration();
return config.getString(propertyName);
}
private static Configuration getPropertiesConfiguration() {
if ( config == null ) {
try {
config = new PropertiesConfiguration("emm.properties");
} catch (ConfigurationException e) {
logger.error("error getting 'emm.properties': ", e);
}
}
return config;
}
// if have something like date_add(now(), interval 7 day ), you should get 7
public static int extractDayFromSysdate(String sysdate) {
Pattern pattern = Pattern.compile("[0-9]{1,}");
Matcher matcher = pattern.matcher(sysdate);
if(matcher.find()) {
return Integer.parseInt(matcher.group());
}
return 0;
}
public static String extractUnitFromSysdate(String sysdate) {
return "DAY";
}
/**
* Escapes any HTML sequence in all values in the given map. The map is altered and returned.
*
* @param htmlMap map to use for escaping HTML sequences
* @return the altered htmlMap
*/
// ---- WARNING ----
// the Hashmap has to be of type <Object,Object> because sometimes other values
// than Strings are coming along. Then you would get a class cast exception
// if the Hashmap would be of type <String, String>.
public static Map escapeHtmlInValues(Map htmlMap) {
Map result = new CaseInsensitiveMap();
if (htmlMap != null) {
for (Object keyObject : htmlMap.keySet()) {
String key = keyObject.toString();
Object value = htmlMap.get(key);
if (value != null)
result.put(key, StringEscapeUtils.escapeHtml(value.toString()));
else {
result.put(key, null);
if (logger.isDebugEnabled())
logger.debug("value for key '" + key + "' is null");
}
}
}
return result;
}
/**
*
* @param startYear
* @return a list of years from the current year back to the start year
*/
public static List<Integer> getYearList(int startYear) {
List<Integer> yearList = new ArrayList<Integer>();
GregorianCalendar calendar = new GregorianCalendar();
int currentYear = calendar.get(Calendar.YEAR);
for(int year = currentYear; year >= startYear; year-- ) {
yearList.add(year);
}
return yearList;
}
public static List<Integer> getCalendarYearList(int startYear) {
List<Integer> yearList = new ArrayList<Integer>();
GregorianCalendar calendar = new GregorianCalendar();
int currentYear = calendar.get(Calendar.YEAR);
for (int year = currentYear + 1; year >= startYear; year--) {
yearList.add(year);
}
return yearList;
}
public static List<String[]> getMonthList() {
List<String[]> monthList = new ArrayList<String[]>();
monthList.add(new String[]{"0","month.january"});
monthList.add(new String[]{"1","month.february"});
monthList.add(new String[]{"2","month.march"});
monthList.add(new String[]{"3","month.april"});
monthList.add(new String[]{"4","month.may"});
monthList.add(new String[]{"5","month.june"});
monthList.add(new String[]{"6","month.juli"});
monthList.add(new String[]{"7","month.august"});
monthList.add(new String[]{"8","month.september"});
monthList.add(new String[]{"9","month.october"});
monthList.add(new String[]{"10","month.november"});
monthList.add(new String[]{"11","month.december"});
return monthList;
}
public static boolean parameterNotEmpty(HttpServletRequest request, String paramName) {
return request.getParameter(paramName) != null && !request.getParameter(paramName).isEmpty();
}
public static String bytesToKbStr(int bytes) {
long kbSize100x = Math.round(bytes / 10.24);
return (kbSize100x / 100) + "." + (kbSize100x % 100);
}
public static int decryptLayoutID(String layout) {
int layoutID = 0;
int index = layout.indexOf('.');
layout = layout.substring(0, index);
layoutID = Integer.parseInt(layout, 36);
return layoutID;
}
public static int decryptCompanyID(String company) {
int companyID = 0;
int index = company.indexOf('.');
company = company.substring(index + 1);
companyID = Integer.parseInt(company, 36);
return companyID;
}
public static File createDirectory(String path) {
File directory = new File(path);
boolean dirCreated;
if (!directory.exists()) {
dirCreated = directory.mkdir();
} else {
dirCreated = true;
}
return dirCreated ? directory : null;
}
public static <T> T nullValue( T value, T valueOnNull) {
return value != null ? value : valueOnNull;
}
public static String getUserErrorMessage(Exception e){
String result = "";
boolean ff=false;
if(e instanceof ParseErrorException){
result += "Line " + ((ParseErrorException) e).getLineNumber();
result += ", column " + ((ParseErrorException) e).getColumnNumber() + ": " ;
String error = e.getMessage();
result += StringEscapeUtils.escapeHtml(error.split("\n")[0]);
ff = true;
}
if(e instanceof MethodInvocationException){
result += "Line " + ((MethodInvocationException) e).getLineNumber();
result += ", column " + ((MethodInvocationException) e).getColumnNumber() + ": " ;
String error = e.getMessage();
result += StringEscapeUtils.escapeHtml(error.split("\n")[0]);
ff = true;
}
if(e instanceof ResourceNotFoundException){
result += "Template not found. \n";
result += StringEscapeUtils.escapeHtml(e.getMessage().split("\n")[0]);
ff = true;
}
if(e instanceof IOException){
result += e.getMessage().split("\n")[0];;
ff = true;
}
if(!ff)
result += e.getMessage().split("\n")[0];
return result;
}
public static boolean sendVelocityExceptionMail(String formUrl, Exception e) {
String targetMail=AgnUtils.getDefaultValue("mailaddress.support");
String senderAddress = AgnUtils.getDefaultValue("mailaddress.sender");
String message="";
message+="Velocity error: \n";
message+=e.getMessage().split("\n")[0];
if(formUrl != null){
message+="\n Form URL: \n";
message+=formUrl;
}
message+="\n Error details: \n";
message+=AgnUtils.getStackTrace(e);
if(targetMail != null) {
try {
return sendEmail(senderAddress, targetMail, null, "EMM Fehler", message, "", 0, "utf-8");
} catch(Exception me) {
logger.error("sendVelocityExceptionMail", e);
return false;
}
}
return true;
}
public static String getAttributeFromParameterString(String params, String attributeName) {
String attribute = "";
// split the parameters
String paramArray[] = params.split(",");
// loop over every entry
for (String item : paramArray) {
if (item.trim().startsWith(attributeName)) {
attribute = item.trim();
}
}
// we dont have that attribute in param-staring
if (attribute == null) {
return null;
}
// now extract the parameter.
attribute = attribute.replace(attributeName + "=", "");
attribute = attribute.replace("\"", "").trim();
return attribute;
}
/**
* Build a string of x repetitions of another string.
* An optional separator is placed between each repetition.
* 0 repetitions return an empty string.
*
* @param itemString
* @param separatorString
* @param repeatTimes
* @return
*/
public static String repeatString(String itemString, int repeatTimes) {
return repeatString(itemString, repeatTimes, null);
}
/**
* Build a string of x repetitions of another string.
* An optional separator is placed between each repetition.
* 0 repetitions return an empty string.
*
* @param itemString
* @param separatorString
* @param repeatTimes
* @return
*/
public static String repeatString(String itemString, int repeatTimes, String separatorString) {
StringBuilder returnStringBuilder = new StringBuilder();
for (int i = 0; i < repeatTimes; i++) {
if (returnStringBuilder.length() > 0 && StringUtils.isNotEmpty(separatorString)) {
returnStringBuilder.append(separatorString);
}
returnStringBuilder.append(itemString);
}
return returnStringBuilder.toString();
}
/**
* Sort a map by a Comparator for the keytype
*
* @param mapToSort
* @param comparator
* @return
*/
public static <KeyType, ValueType> Map<KeyType, ValueType> sortMap(Map<KeyType, ValueType> mapToSort, Comparator<KeyType> comparator) {
List<KeyType> keys = new ArrayList<KeyType>(mapToSort.keySet());
Collections.sort(keys, comparator);
LinkedHashMap<KeyType, ValueType> sortedContent = new LinkedHashMap<KeyType, ValueType>();
for (KeyType key : keys) {
sortedContent.put(key, mapToSort.get(key));
}
return sortedContent;
}
/**
* Splits String into a list of strings separating text values from number values
* Example: "abcd 23.56 ueyr76" will be split to "abcd ", "23", ".", "56", " ueyr", "76"
*
* @param str string to split
* @return split-list of strings
*/
public static List<String> splitIntoNumbersAndText(String mixedString) {
List<String> tokens = new ArrayList<String>();
if (StringUtils.isNotEmpty(mixedString)) {
StringBuilder numberToken = null;
StringBuilder textToken = null;
for (char charValue : mixedString.toCharArray()) {
if (Character.isDigit(charValue)) {
if (numberToken == null)
numberToken = new StringBuilder();
numberToken.append(charValue);
if (textToken != null) {
tokens.add(textToken.toString());
textToken = null;
}
}
else {
if (textToken == null)
textToken = new StringBuilder();
textToken.append(charValue);
if (numberToken != null) {
tokens.add(numberToken.toString());
numberToken = null;
}
}
}
}
return tokens;
}
/**
* Check if a string only consists of digits.
* No signing (+-) or punctuation is allowed.
*
* @param value
* @return
*/
public static boolean isDigit(String value){
for (char charValue : value.toCharArray()) {
if (!Character.isDigit(charValue))
return false;
}
return true;
}
public static boolean interpretAsBoolean(String value) {
return value != null
&& ("true".equalsIgnoreCase(value)
|| "yes".equalsIgnoreCase(value)
|| "on".equalsIgnoreCase(value)
|| "allowed".equalsIgnoreCase(value)
|| "1".equals(value)
|| "+".equals(value));
}
/**
* Remove specific framing tag elements from a string.
*
* e.g:
* "startingtext <prev>wanted text</prev> trailingtext"
* => "wanted text"
*
* @param tagContainingString
* @param tagName
* @return
*/
public static String getStringWithoutTagFrame(String tagContainingString, String tagName) {
// find first occurence of start
int tagStart = tagContainingString.indexOf("<" + tagName + ">");
int tagEnd = -1;
// find following occurence of end
if (tagStart > -1) {
tagEnd = tagContainingString.indexOf("</" + tagName + ">", tagStart);
} else {
tagEnd = tagContainingString.indexOf("</" + tagName + ">");
}
// find shortest enclosed part
if (tagEnd > -1 && tagStart > -1) {
tagStart = tagContainingString.lastIndexOf("<" + tagName + ">", tagEnd);
}
// return enclosed part or original string
if (tagStart > -1 && tagEnd > tagStart) {
return tagContainingString.substring(tagStart + 5, tagEnd);
} else if (tagStart > -1) {
return tagContainingString.substring(tagStart + 5);
} else if (tagEnd > -1) {
return tagContainingString.substring(0, tagEnd);
} else {
return tagContainingString;
}
}
public static URL addUrlParameter(URL url, String parameterName, String parameterValue) throws UnsupportedEncodingException, MalformedURLException {
return addUrlParameter(url, parameterName, parameterValue, null);
}
public static URL addUrlParameter(URL url, String parameterName, String parameterValue, String encodingCharSet) throws UnsupportedEncodingException, MalformedURLException {
return new URL(addUrlParameter(url.toString(), parameterName, parameterValue, encodingCharSet));
}
public static String addUrlParameter(String url, String parameterName, String parameterValue) throws UnsupportedEncodingException {
return addUrlParameter(url, parameterName, parameterValue, null);
}
public static String addUrlParameter(String url, String parameterName, String parameterValue, String encodingCharSet) throws UnsupportedEncodingException {
StringBuilder escapedParameterNameAndValue = new StringBuilder();
if (StringUtils.isEmpty(encodingCharSet)) {
escapedParameterNameAndValue.append(parameterName);
} else {
escapedParameterNameAndValue.append(URLEncoder.encode(parameterName, encodingCharSet));
}
escapedParameterNameAndValue.append('=');
if (StringUtils.isEmpty(encodingCharSet)) {
escapedParameterNameAndValue.append(parameterValue);
} else {
escapedParameterNameAndValue.append(URLEncoder.encode(parameterValue, encodingCharSet));
}
return addUrlParameter(url, escapedParameterNameAndValue.toString());
}
public static String addUrlParameter(String url, String escapedParameterNameAndValue) throws UnsupportedEncodingException {
StringBuilder newUrl = new StringBuilder();
int hpos = url.indexOf('#');
if (hpos > -1) {
newUrl.append(url.substring(0, hpos));
} else {
newUrl.append(url);
}
newUrl.append(url.indexOf('?') <= -1 ? '?' : '&');
newUrl.append(escapedParameterNameAndValue);
if (hpos > -1) {
newUrl.append(url.substring(hpos));
}
return newUrl.toString();
}
public static int getLineCountOfFile(File file) throws IOException {
LineNumberReader lineNumberReader = null;
try {
lineNumberReader = new LineNumberReader(new InputStreamReader(new FileInputStream(file)));
while (lineNumberReader.readLine() != null) {
}
return lineNumberReader.getLineNumber();
} finally {
IOUtils.closeQuietly(lineNumberReader);
}
}
public static InternetAddress[] getEmailAddressesFromList(String listString) {
if (StringUtils.isNotBlank(listString)) {
List<InternetAddress> emailAddresses = new ArrayList<InternetAddress>();
for (String singleAdr : listString.split(";|,| ")) {
singleAdr = singleAdr.trim();
if (StringUtils.isNotBlank(singleAdr)) {
try {
InternetAddress nextAddress = new InternetAddress(singleAdr.trim());
nextAddress.validate();
emailAddresses.add(nextAddress);
} catch (AddressException e) {
logger.error("Invalid Emailaddress found: " + singleAdr);
}
}
}
return emailAddresses.toArray(new InternetAddress[emailAddresses.size()]);
} else {
return new InternetAddress[0];
}
}
public static String getHostName() {
try {
return InetAddress.getLocalHost().getHostName();
} catch (java.net.UnknownHostException uhe) {
return "unknown hostname";
}
}
/**
* Chop a string in pieces with maximum length of chunkSize
*/
public static List<String> chopToChunks(String text, int chunkSize) {
List<String> returnList = new ArrayList<String>((text.length() + chunkSize - 1) / chunkSize);
for (int start = 0; start < text.length(); start += chunkSize) {
returnList.add(text.substring(start, Math.min(text.length(), start + chunkSize)));
}
return returnList;
}
public static UUID generateNewUUID() {
return UUID.randomUUID();
}
public static String convertToHexString(UUID uuid) {
return convertToHexString(uuid, false);
}
public static String convertToHexString(UUID uuid, boolean removeHyphens) {
return uuid.toString().toUpperCase().replace("-", "");
}
public static String convertToBase64String(UUID uuid) {
byte[] data = convertToByteArray(uuid);
return encodeBase64(data);
}
public static String encodeBase64(byte[] data) {
return Base64.encode(data);
}
public static byte[] decodeBase64(String data) {
return Base64.decode(data);
}
public static byte[] convertToByteArray(UUID uuid) {
long msb = uuid.getMostSignificantBits();
long lsb = uuid.getLeastSignificantBits();
byte[] buffer = new byte[16];
for (int i = 0; i < 8; i++) {
buffer[i] = (byte) (msb >>> 8 * (7 - i));
}
for (int i = 8; i < 16; i++) {
buffer[i] = (byte) (lsb >>> 8 * (7 - i));
}
return buffer;
}
public static UUID convertToUUID(byte[] byteArray) {
if (byteArray.length != 16) {
throw new IllegalArgumentException("Length of bytearray doesn't fit for UUID");
}
long msb = 0;
long lsb = 0;
for (int i = 0; i < 8; i++) {
msb = (msb << 8) | (byteArray[i] & 0xFF);
}
for (int i = 8; i < 16; i++) {
lsb = (lsb << 8) | (byteArray[i] & 0xFF);
}
return new UUID(msb, lsb);
}
private static SecureRandom random = new SecureRandom();
private static final char[] allCharacters = "0123456789abcdefghijklmnopqrstuvwxyz".toCharArray();
public static String getRandomString(int length) {
char[] buffer = new char[length];
for (int i = 0; i < buffer.length; ++i) {
buffer[i] = allCharacters[random.nextInt(allCharacters.length)];
}
return new String(buffer);
}
public static boolean dayListIncludes(List<GregorianCalendar> listOfDays, GregorianCalendar day) {
for (GregorianCalendar listDay : listOfDays) {
if (listDay.get(Calendar.DAY_OF_YEAR) == day.get(Calendar.DAY_OF_YEAR))
return true;
}
return false;
}
public static boolean anyCharsAreEqual(char... values) {
for (int i = 0; i < values.length; i++) {
for (int j = i + 1; j < values.length; j++) {
if (values[i] == values[j]) {
return true;
}
}
}
return false;
}
public static boolean isNumber(String value) {
try {
Integer.parseInt(value);
return true;
} catch (NumberFormatException e) {
return false;
}
}
/**
* Call lowercase and trim on email address.
* Watch out: apostrophe and other special characters !#$%&'*+-/=?^_`{|}~ are allowed in local parts of emailaddresses
*
* @param email
* @return
*/
public static String normalizeEmail(String email) {
if (StringUtils.isBlank(email)) {
return null;
} else {
return email.toLowerCase().trim();
}
}
public static String checkAndNormalizeEmail(String email) throws Exception {
if (StringUtils.isBlank(email)) {
throw new Exception("Empty email address");
} else {
if (!EmailValidator.getInstance().isValid(StringOps.punycoded(email))) {
throw new Exception("Invalid email address");
} else {
return normalizeEmail(email);
}
}
}
public static boolean compareByteArrays(byte[] array1, byte[] array2) {
if (array1 == array2) {
return true;
} else if (array1 == null || array2 == null || array1.length != array2.length) {
return false;
} else {
for (int i = 0; i < array1.length; i++) {
if (array1[i] != array2[i]) {
return false;
}
}
return true;
}
}
public static String getSmtpMailRelayHostname() {
String returnValue = "localhost";
try {
String configValue = AgnUtils.getDefaultValue("system.mail.host");
if (StringUtils.isNotBlank(configValue)) {
returnValue = configValue;
}
} catch (Exception e) {
}
return returnValue;
}
public static int getValidPageNumber(int fullListSize, int page, int rownums) {
int pageNumber = page;
double doubleFullListSize = fullListSize;
double doublePageSize = rownums;
int lastPagenumber = (int) Math.ceil(doubleFullListSize / doublePageSize);
if (lastPagenumber < pageNumber) {
pageNumber = 1;
}
return pageNumber;
}
public static String getStringFromNull(String source) {
if(source.equals("null")) {
return "";
} else {
return source;
}
}
public static String replaceHashTags(String hashTagString, Map<String, Object>... replacementMaps) {
if (StringUtils.isBlank(hashTagString)) {
return hashTagString;
} else {
String returnString = hashTagString;
Pattern pattern = Pattern.compile("##([^#]+)##");
Matcher matcher = pattern.matcher(hashTagString);
int currentPosition = 0;
while (matcher.find(currentPosition)) {
int matcherStart = matcher.start();
String tagNameString = matcher.group(1);
String[] referenceKeys = tagNameString.split("/");
String replacementValue = null;
if (replacementMaps != null) {
for (String referenceKey : referenceKeys) {
for (Map<String, Object> replacementMap : replacementMaps) {
if (replacementMap != null) {
Object replacementData = replacementMap.get(referenceKey);
if (replacementData != null) {
String replacementDataString = replacementData.toString();
if (StringUtils.isNotEmpty(replacementDataString)) {
replacementValue = replacementData.toString();
break;
}
}
}
}
if (replacementValue != null) {
break;
}
}
}
if (replacementValue == null) {
replacementValue = "";
}
returnString = matcher.replaceAll(replacementValue);
matcher = pattern.matcher(returnString);
currentPosition += matcherStart + replacementValue.length();
}
return returnString;
}
}
}