CmsPropertyHandler.java

/* ===============================================================================
 *
 * Part of the InfoGlue Content Management Platform (www.infoglue.org)
 *
 * ===============================================================================
 *
 *  Copyright (C)
 * 
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License version 2, as published by the
 * Free Software Foundation. See the file LICENSE.html for more information.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY, including the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc. / 59 Temple
 * Place, Suite 330 / Boston, MA 02111-1307 / USA.
 *
 * ===============================================================================
 */

package org.infoglue.cms.util;

import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Properties;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.log4j.Logger;
import org.infoglue.cms.applications.managementtool.actions.deployment.DeploymentServerBean;
import org.infoglue.cms.applications.managementtool.actions.deployment.VersionControlServerBean;
import org.infoglue.cms.controllers.kernel.impl.simple.ContentTypeDefinitionController;
import org.infoglue.cms.controllers.kernel.impl.simple.InstallationController;
import org.infoglue.cms.controllers.kernel.impl.simple.LabelController;
import org.infoglue.cms.controllers.kernel.impl.simple.ServerNodeController;
import org.infoglue.cms.controllers.kernel.impl.simple.ThemeController;
import org.infoglue.cms.entities.management.ContentTypeAttribute;
import org.infoglue.cms.entities.management.ContentTypeDefinitionVO;
import org.infoglue.cms.entities.management.ServerNodeVO;
import org.infoglue.deliver.util.CacheController;
import org.infoglue.deliver.util.HttpHelper;
import org.infoglue.deliver.util.NullObject;
import org.infoglue.deliver.util.Timer;

import com.opensymphony.module.propertyset.PropertyException;
import com.opensymphony.module.propertyset.PropertySet;
import com.opensymphony.module.propertyset.PropertySetManager;



/**
 * CMSPropertyHandler.java
 * Created on 2002-sep-12 
 * 
 * This class is used to get properties for the system in a transparent way.
 * The second evolution of this class made it possible for properties to be fetched from the propertyset if there instead. Fallback to file.
 * 
 * @author Stefan Sik, ss@frovi.com
 * @author Mattias Bogeblad 
 */

public class CmsPropertyHandler
{
	private final static Logger logger = Logger.getLogger(CmsPropertyHandler.class.getName());

	private final static HttpHelper httpHelper = new HttpHelper();

	private static Properties cachedProperties 		= null;
	private static PropertySet propertySet			= null; 

	private static String serverNodeName			= null;
	private static String digitalAssetPortletRegistryId = null;

	private static String globalSettingsServerNodeId= "-1";
	private static String localSettingsServerNodeId	= null;

	private static String applicationName 			= null;
	private static String contextRootPath 			= null;
	private static String defaultScheme				= null;
	private static Integer defaultPort				= null;
	private static String operatingMode				= null;
	private static File propertyFile 				= null;
	private static Date startupTime					= null;
	private static String servletContext 			= null;

	//Variables which are caches very hard but must be cleared roughly
	private static String inputCharacterEncoding 					= null;
	private static String enforceRigidContentAccess 				= null;
	private static String niceURIEncoding							= null;
	private static String defaultNumberOfYearsBeforeExpire			= null;
	private static String defaultNumberOfMonthsBeforeRedirectExpire	= null;
	private static String setDerivedLastModifiedInLive				= null;
	private static String digitalAssetPath0							= null;
	private static String enableNiceURI								= null;
	private static String useImprovedContentCategorySearch			= null;
	private static String enablePortal								= null;
	private static String useAccessBasedProtocolRedirects			= null;
	private static Boolean useHashCodeInCaches						= null;
	private static Boolean useSynchronizationOnCaches				= null;
	private static Map cacheSettings								= null;
	private static Properties generalSettings						= null;

	public static String getDigitalAssetPortletRegistryId()
	{
		 return digitalAssetPortletRegistryId;
	}
	public static void setApplicationName(String theApplicationName)
	{
		CmsPropertyHandler.applicationName = theApplicationName;
	}

	public static void setContextRootPath(String contextRootPath)
	{
		CmsPropertyHandler.contextRootPath = contextRootPath;
	}

	public static void registerDefaultSchemeAndPort(HttpServletRequest request)
	{
		if(defaultScheme == null || defaultPort == null && request != null)
		{
			defaultScheme = request.getScheme();
			defaultPort = request.getLocalPort();
			logger.info("Registered defaultScheme:" + defaultScheme + " and defaultPort:" + defaultPort);
		}
	}
	
	public static String getServletContext()
	{
		return servletContext;
	}

	public static void setServletContext(String servletContext)
	{
		CmsPropertyHandler.servletContext = servletContext;
	}

	public static void setOperatingMode(String operatingMode)
	{
		CmsPropertyHandler.operatingMode = operatingMode;
	}

	public static String getApplicationName()
	{
		return applicationName;
	}

	public static void setStartupTime(Date startupTime)
	{
		CmsPropertyHandler.startupTime = startupTime;
	}

	public static Date getStartupTime()
	{
		return startupTime;
	}

	public static void setPropertyFile(File aPropertyFile)
	{
		propertyFile = aPropertyFile;
	}
	
	/**
	 * This method initializes the parameter hash with values.
	 */

	public static void initializeProperties()
	{
	    try
		{
	    	Timer timer = new Timer();
	    	timer.setActive(false);
	    	
			System.out.println("Initializing properties from file.....");
			
			cachedProperties = new Properties();
			if(propertyFile != null)
			    cachedProperties.load(new FileInputStream(propertyFile));
			else
				cachedProperties.load(CmsPropertyHandler.class.getClassLoader().getResource("/" + applicationName + ".properties").openStream());
			    //cachedProperties.load(CmsPropertyHandler.class.getResourceAsStream("/" + applicationName + ".properties"));

			digitalAssetPortletRegistryId = cachedProperties.getProperty("digitalAssetPortletRegistryId");

			if(logger.isInfoEnabled())
				cachedProperties.list(System.out);
			
			Enumeration enumeration = cachedProperties.keys();
			while(enumeration.hasMoreElements())
			{
				String key = (String)enumeration.nextElement();
				if(key.indexOf("webwork.") > 0)
				{
					webwork.config.Configuration.set(key, cachedProperties.getProperty(key)); 
				}
			}
			
		    timer.printElapsedTime("Initializing properties from file took");

	        Map args = new HashMap();
		    args.put("globalKey", "infoglue");
		    try
		    {
		    	propertySet = PropertySetManager.getInstance("jdbc", args);
		    	if(logger.isInfoEnabled())
		    		logger.info("propertySet: " + propertySet);
		    }
		    catch(Exception e)
		    {
		    	propertySet = null;
		    	logger.error("Could not get property set: " + e.getMessage(), e);
		    }
		    
		    timer.printElapsedTime("Initializing properties from jdbc");

		    serverNodeName = cachedProperties.getProperty("serverNodeName");
		    
		    if(serverNodeName == null || serverNodeName.length() == 0)
		    {
		    	try
		    	{
				    InetAddress localhost = InetAddress.getLocalHost();
				    serverNodeName = localhost.getHostName();
		    	}
		    	catch(Exception e)
		    	{
		    		logger.error("Error initializing serverNodeName:" + e.getMessage());
		    	}
		    }
		    
		    logger.info("serverNodeName:" + serverNodeName);
		    
		    initializeLocalServerNodeId();
		    
		    timer.printElapsedTime("Initializing properties from local server jdbc");
		}	
		catch(Exception e)
		{
			cachedProperties = null;
			logger.error("Error loading properties from file " + "/" + applicationName + ".properties" + ". Reason:" + e.getMessage());
			e.printStackTrace();
		}
	}
	
	public static void resetHardCachedSettings()
	{
		logger.info("Resetting hard cached settings...");
		
		String newInputCharacterEncoding = getInputCharacterEncoding(SetCharacterEncodingFilter.defaultEncoding, true);
		String newEnforceRigidContentAccess = getEnforceRigidContentAccess(true);
		String newNiceURIEncodingg = getNiceURIEncoding(true);
		String newDefaultNumberOfYearsBeforeExpire = getDefaultNumberOfYearsBeforeExpire(true);
		String newDefaultNumberOfMonthsBeforeRedirectExpire = getDefaultNumberOfMonthsBeforeRedirectExpire(true);
		String newSetDerivedLastModifiedInLive = getSetDerivedLastModifiedInLive(true);
		String newDigitalAssetPath0 = getDigitalAssetPath0(true);
		String newEnableNiceURI = getEnableNiceURI(true);
		String newUseImprovedContentCategorySearch = getUseImprovedContentCategorySearch(true);
		String newEnablePortal = getEnablePortal(true);
		String newUseAccessBasedProtocolRedirects = getUseAccessBasedProtocolRedirects(true);
		Boolean newUseHashCodeInCaches = getUseHashCodeInCaches(true);
		Boolean newUseSynchronizationOnCaches = getUseSynchronizationOnCaches(true);
		String newOperatingMode = getOperatingMode(true);
		Map newCacheSettings = getCacheSettings(true);
		Properties newGeneralSettings = getGeneralSettings(true);

		inputCharacterEncoding 						= newInputCharacterEncoding;
		enforceRigidContentAccess 					= newEnforceRigidContentAccess;
		niceURIEncoding								= newNiceURIEncodingg;
		defaultNumberOfYearsBeforeExpire 			= newDefaultNumberOfYearsBeforeExpire;
		defaultNumberOfMonthsBeforeRedirectExpire	= newDefaultNumberOfMonthsBeforeRedirectExpire;
		setDerivedLastModifiedInLive 				= newSetDerivedLastModifiedInLive;
		digitalAssetPath0							= newDigitalAssetPath0;
		enableNiceURI								= newEnableNiceURI;
		useImprovedContentCategorySearch			= newUseImprovedContentCategorySearch;
		enablePortal								= newEnablePortal;
		useAccessBasedProtocolRedirects 			= newUseAccessBasedProtocolRedirects;
		useHashCodeInCaches 						= newUseHashCodeInCaches;
		useSynchronizationOnCaches					= newUseSynchronizationOnCaches;
		operatingMode 								= newOperatingMode;
		cacheSettings 								= newCacheSettings;
		generalSettings								= newGeneralSettings;

		logger.info("Done resetting hard cached settings...");
	}
	
	public static String getServerName()
    {
    	String serverName = "Unknown";

    	try
    	{
		    InetAddress localhost = InetAddress.getLocalHost();
		    serverName = localhost.getHostName();
    	}
    	catch(Exception e)
    	{
    		
    	}
    	
	    return serverName;
    }

	/**
	 * This method gets the local server node id if available.
	 */

	public static void initializeLocalServerNodeId()
	{
        try
	    {
	        List serverNodeVOList = ServerNodeController.getController().getServerNodeVOList();
	        Iterator serverNodeVOListIterator = serverNodeVOList.iterator();
	        while(serverNodeVOListIterator.hasNext())
	        {
	            ServerNodeVO serverNodeVO = (ServerNodeVO)serverNodeVOListIterator.next();
	            if(serverNodeVO.getName().equalsIgnoreCase(serverNodeName))
	            {
	                localSettingsServerNodeId = serverNodeVO.getId().toString();
	                break;
	            }
	        }
	    }
	    catch(Exception e)
	    {
	        logger.warn("An error occurred trying to get localSettingsServerNodeId: " + e.getMessage(), e);
	    }
	    
	    System.out.println("localSettingsServerNodeId:" + localSettingsServerNodeId);
	}
	
	/**
	 * This method returns all properties .
	 */

	public static Properties getProperties()
	{
		if(cachedProperties == null)
			initializeProperties();
				
		return cachedProperties;
	}	

 
	/**
	 * This method returns a propertyValue corresponding to the key supplied.
	 */

	public static String getProperty(String key)
	{
		String value;
		if(cachedProperties == null)
			initializeProperties();
		
		value = cachedProperties.getProperty(key);
		if (value != null)
			value = value.trim();
				
		return value;
	}	

	/**
	 * This method returns a propertyValue corresponding to the key supplied.
	 */

	public static String getProperty(String key, String defaultValue)
	{
		String value;
		if(cachedProperties == null)
			initializeProperties();
		
		value = cachedProperties.getProperty(key);
		if (value != null)
			value = value.trim();
		else
			value = defaultValue;
				
		return value;
	}	
	
	/**
	 * This method sets a property during runtime.
	 */

	public static void setProperty(String key, String value)
	{
		if(cachedProperties == null)
			initializeProperties();
		
		cachedProperties.setProperty(key, value);
		
		CacheController.clearServerNodeProperty(false);
	}	

	public static String getServerNodeProperty(String key, boolean inherit)
	{
		return getServerNodeProperty(null, key, inherit, null);
	}

	public static String getServerNodeProperty(String key, boolean inherit, String defaultValue)
	{
		return getServerNodeProperty(null, key, inherit, defaultValue, false);
	}

	public static String getServerNodeProperty(String key, boolean inherit, String defaultValue, boolean skipCaches)
	{
		return getServerNodeProperty(null, key, inherit, defaultValue, skipCaches);
	}

	/**
	 * This method gets the serverNodeProperty but also fallbacks to the old propertyfile if not found in the propertyset.
	 * 
	 * @param key
	 * @param inherit
	 * @return
	 */
	public static String getServerNodeProperty(String prefix, String key, boolean inherit, String defaultValue)
	{
		return getServerNodeProperty(prefix, key, inherit, defaultValue, false);
	}
	
	public static String getServerNodeProperty(String prefix, String key, boolean inherit, String defaultValue, boolean skipCaches)
	{
		try
		{
			String value = null;
		    Object valueObject = null;
		    
		    StringBuffer sb = new StringBuffer();
		    sb.append(prefix).append("_").append(key).append("_").append(inherit);
		    
		    String cacheKey = sb.toString(); //"" + prefix + "_" + key + "_" + inherit;
	        String cacheName = "serverNodePropertiesCache";
	        
			if(logger.isInfoEnabled())
				logger.info("cacheKey:" + cacheKey);
			
			if(!skipCaches)
				valueObject = CacheController.getCachedObject(cacheName, cacheKey);
			
			if(valueObject != null)
			{
				if(valueObject instanceof NullObject)
					return null;
				else	
					return ((String)valueObject).trim();
			}
		    
			Timer timer = new Timer();
			
			if(logger.isInfoEnabled())
				logger.info("Getting jdbc-property:" + cacheKey);
			
			if(propertySet != null)
			{
				if(localSettingsServerNodeId != null)
			    {
			    	if(prefix != null)
			    	{
				        value = propertySet.getString("serverNode_" + localSettingsServerNodeId + "_" + prefix + "_" + key);
				        if(value == null || value.equals("") || value.equalsIgnoreCase("inherit") && inherit)
				        {
				            value = propertySet.getString("serverNode_" + globalSettingsServerNodeId + "_" + prefix + "_" + key);
					        if(value == null || value.equals("") || value.equalsIgnoreCase("inherit") && inherit)
					        {
					            value = propertySet.getString("serverNode_" + globalSettingsServerNodeId + "_" + key);
						    }
		
				        }
			    	}
			    	else
			    	{
				        value = propertySet.getString("serverNode_" + localSettingsServerNodeId + "_" + key);
				        if(value == null || value.equals("") || value.equalsIgnoreCase("inherit") && inherit)
				        {
				            value = propertySet.getString("serverNode_" + globalSettingsServerNodeId + "_" + key);
					    }	    		
			    	}
			    }
				else
				{
					if(prefix != null)
			    	{
						value = propertySet.getString("serverNode_" + globalSettingsServerNodeId + "_" + prefix + "_" + key);
						if(value == null || value.equals("") || value.equalsIgnoreCase("inherit") && inherit)
				        {
				            value = propertySet.getString("serverNode_" + globalSettingsServerNodeId + "_" + key);
					    }	    		
			    	}
					else
					{
						value = propertySet.getString("serverNode_" + globalSettingsServerNodeId + "_" + key);
					}
			    }
				
				if(value == null || value.equals("") || value.equalsIgnoreCase("inherit") && inherit)
			    {
					value = propertySet.getString(key);
			    }
			}
			
		    if(value == null || value.equals("") || value.equalsIgnoreCase("inherit") && inherit)
		    {
		        value = getProperty(key);
		    }
	
		    if((value == null || value.indexOf(key) > -1) && defaultValue != null)
		    	value = defaultValue;
		    
		    if(value != null)
		    	value = value.trim();
		    
		    if(!skipCaches)
		    {
			    if(value != null)
			    	CacheController.cacheObject(cacheName, cacheKey, value);
			    else
			    	CacheController.cacheObject(cacheName, cacheKey, new NullObject());
		    }
	
		    if(logger.isInfoEnabled())
				logger.info("Getting property " + cacheKey + " took:" + timer.getElapsedTime());
		    
		    return value;
		}
		catch(Exception e)
		{
			logger.error("Problem getting property: " + e.getMessage()/*, e*/);
			return defaultValue;
		}
	}


	public static String getServerNodeDataProperty(String prefix, String key, boolean inherit, String defaultValue)
	{
		return getServerNodeDataProperty(prefix, key, inherit, defaultValue, false);
	}

	/**
	 * This method gets the serverNodeDataProperty.
	 * 
	 * @param key
	 * @param inherit
	 * @return
	 */
	
	public static String getServerNodeDataProperty(String prefix, String key, boolean inherit, String defaultValue, boolean skipCache)
	{
		try
		{
		    String value = null;
		    
	        String cacheKey = "" + prefix + "_" + key + "_" + inherit;
	        String cacheName = "serverNodePropertiesCache";
	        
	        if(logger.isInfoEnabled())
	    		logger.info("cacheKey:" + cacheKey);
			
	        if(!skipCache)
	        {
		        value = (String)CacheController.getCachedObject(cacheName, cacheKey);
				if(value != null)
				{
					return value;
				}
	        }
	        
			Timer timer = new Timer();
	
			if(logger.isInfoEnabled())
				logger.info("Getting jdbc-property:" + cacheKey);
		    
			if(localSettingsServerNodeId != null)
		    {
		    	if(prefix != null)
		    	{
			        value = getDataPropertyValue("serverNode_" + localSettingsServerNodeId + "_" + prefix + "_" + key);
			        if(value == null || value.equals("") || value.equalsIgnoreCase("inherit") && inherit)
			        {
			            value = getDataPropertyValue("serverNode_" + globalSettingsServerNodeId + "_" + prefix + "_" + key);
				        if(value == null || value.equals("") || value.equalsIgnoreCase("inherit") && inherit)
				        {
				            value = getDataPropertyValue("serverNode_" + globalSettingsServerNodeId + "_" + key);
				        }
	
			        }
		    	}
		    	else
		    	{
			        value = getDataPropertyValue("serverNode_" + localSettingsServerNodeId + "_" + key);
			        if(value == null || value.equals("") || value.equalsIgnoreCase("inherit") && inherit)
			        {
			            value = getDataPropertyValue("serverNode_" + globalSettingsServerNodeId + "_" + key);
			        }	    		
		    	}
		    }
			else
			{
				if(prefix != null)
		    	{
					value = getDataPropertyValue("serverNode_" + globalSettingsServerNodeId + "_" + prefix + "_" + key);
		    	}
				else
				{
					value = getDataPropertyValue("serverNode_" + globalSettingsServerNodeId + "_" + key);
				}
		    }
			
		    if(value == null && defaultValue != null)
		    	value = defaultValue;
		    
		    //H�r skall smartare l�sning in sen f�r att l�sa fallback.
		    if(!skipCache)
		    	CacheController.cacheObject(cacheName, cacheKey, value);
		    
		    if(logger.isInfoEnabled())
				logger.info("Getting property " + cacheKey + " took:" + timer.getElapsedTime());
		    
		    return value;
	    
		}
		catch(Exception e)
		{
			logger.error("Problem getting property: " + e.getMessage()/*, e*/);
			return defaultValue;
		}
	}
	
	public static String getDataPropertyValue(String fullKey)
	{
		String result = null;
		
		try
		{
			byte[] valueBytes = getPropertySet().getData(fullKey);
	    
			result = (valueBytes != null ? new String(valueBytes, "utf-8") : "");
		}
		catch(PropertyException pe)
		{
			logger.error("Error getting DataPropertyValue for " + fullKey + ":" + pe.getMessage());
		}
		catch(Exception e)
		{
			logger.error("Error getting DataPropertyValue for " + fullKey + ":" + e.getMessage(), e);
		}
		
		return result;
	}
	
	private static void restorePropertySet()
	{
		Map args = new HashMap();
	    args.put("globalKey", "infoglue");
	    try
	    {
	    	propertySet = PropertySetManager.getInstance("jdbc", args);
	    	if(propertySet != null)
	    		logger.error("Restored propertyset ");
	    	else
	    		logger.error("Could not restore propertyset ");	
	    }
	    catch(Exception e)
	    {
	    	propertySet = null;
	    	logger.error("Could not get property set: " + e.getMessage(), e);
	    }
	}
	
	public static String getContextRootPath()
	{
	    return contextRootPath; //getProperty("contextRootPath"); Concurrency issues...
	}

	public static String getContextDiskPath()
	{
		String contextDiskPath = getProperty("contextDiskPath");
		
		if(contextDiskPath == null || contextDiskPath.equals("") || contextDiskPath.contains("@"))
			return getContextRootPath();
		else
			return contextDiskPath;
	}

	public static String getOperatingMode()
	{
		//if(true)
		//	return "3";
		
		if(operatingMode == null)
			return getProperty("operatingMode");
		else
			return operatingMode; //getProperty("operatingMode"); Concurrency issues...
	}

	public static String getOperatingMode(boolean skipHardCache)
	{
		//if(true)
		//	return "3";

		if(operatingMode == null || skipHardCache)
		{
			operatingMode = getProperty("operatingMode");
		}
		
		return operatingMode;
	}
	
	public static boolean getActuallyBlockOnBlockRequests()
	{
		if(!getOperatingMode().equalsIgnoreCase("3"))
			return true;
		else
			return false;
	}

	//TODO - refresh if changed....
	public static String getInputCharacterEncoding(String defaultEncoding)
	{
		return getInputCharacterEncoding(defaultEncoding, false);
	}
	
	public static String getInputCharacterEncoding(String defaultEncoding, boolean skipHardCache)
	{
		if(inputCharacterEncoding == null || skipHardCache)
		{
			String applicationName = CmsPropertyHandler.getApplicationName();
			String newInputCharacterEncoding = CmsPropertyHandler.getServerNodeProperty("inputCharacterEncoding", true, defaultEncoding);
			if(!applicationName.equalsIgnoreCase("cms"))
				newInputCharacterEncoding = CmsPropertyHandler.getServerNodeProperty("deliver", "inputCharacterEncoding", true, defaultEncoding);

			inputCharacterEncoding = newInputCharacterEncoding;
		}
		//return newInputCharacterEncoding;
		return inputCharacterEncoding;
	}

	/**
	 * @param input The input to parse. The method assumes the format is '\uXXXX'.
	 * @param failSafetly If true the method returns an empty String if an exception occurs, otherwise the exception is thrown from the method.
	 * @return A parsed String
	 * @throws Throwable If <em>failSafetly</em> is false any exception that occurs during parsing is thrown from the method, otherwise no exception is thrown.
	 */
	protected static String parseUnicodeString(String input, boolean failSafetly)
	{
		if (failSafetly)
		{
			try
			{
				return new String(Character.toString((char)Integer.parseInt(input.substring(2), 16)));
			}
			catch (Throwable tr)
			{
				logger.warn("Failed to parse character in CustomCharactersForConversion. Will add an empty String to the array instead. Value: " + input, tr);
				return "";
			}
		}
		else
		{
			return new String(Character.toString((char)Integer.parseInt(input.substring(2), 16)));
		}
	}

	/**
	 * Returns a comma-seperated list that can be used to verify if a String needs to be encoding-converted.
	 * 
	 * This value can be defined by users of the system and can therefore contain any type of values, however the expected format
	 * is a comma-seperated String with one character in each entity. If no value is provided by the user a default set of Swedish
	 * characters will be used.
	 */
	public static String getCustomCharactersForConversion()
	{
		return getServerNodeProperty("customCharactersForConversion", true, "\u00E5,\u00E4,\u00F6");
	}
	
	/**
	 * Returns an array of Strings that can be used to verify if a String needs to be encoding-converted.
	 * 
	 * This value can be defined by users of the system and can therefore contain any type of values, however the expected format
	 * is one character per entity in the array. If no value is provided by the user a default set of Swedish characters will be used.
	 * 
	 */
	public static String[] getCustomCharactersForConversionParsed()
	{
		String characterString = getCustomCharactersForConversion();

		String[] result = null;
		if (characterString.indexOf("\\u") == -1)
		{
			logger.info("Returning simple value for custom characters for conversion.");
			result = characterString.split(",");
		}
		else
		{
			logger.info("Parsing value for custom characters for conversion.");
			String[] values = characterString.split(",");
			result = new String[values.length];
			for (int i = 0; i < result.length; i++)
			{
				result[i] = parseUnicodeString(values[i], true);
			}
		}
		if (logger.isDebugEnabled())
		{
			logger.debug("CustomCharactersForConversion: " + Arrays.toString(result));
		}
		return result;
	}

	public static boolean getEnableCustomCharactersParsing()
	{
		String value = getServerNodeProperty("enableCustomCharactersParsing", true, "true");
		return new Boolean(value);
	}

	public static String getUp2dateUrl()
	{
	    return getProperty("up2dateUrl");
	}

	public static String getURLComposerClass()
	{
	    return getProperty("URLComposerClass");
	}

	public static String getMaxClients()
	{
	    return getProperty("maxClients");
	}

	public static String getAllowedDirectLoginNames()
	{
	    return getServerNodeProperty("allowedDirectLoginNames", true, "eventPublisher");
	}
	
	public static String getAdministratorUserName()
	{
	    return getProperty("administratorUserName");
	}
	/*
	public static String getAdministratorPassword()
	{
	    return getProperty("administratorPassword");
	}
	*/

	public static boolean getMatchesAdministratorPassword(String password)
	{
		try
		{
			if(CmsPropertyHandler.getUsePasswordEncryption())
			{
				byte[] encryptedPassRaw = DigestUtils.sha(password);
				String encryptedPass = new String(Base64.encodeBase64(encryptedPassRaw), "ASCII");
				password = encryptedPass;
			}
			
			String administratorPassword = getProperty("administratorPassword");
			if(administratorPassword != null && !administratorPassword.equals("") && !administratorPassword.equals("@administratorPassword@"))
				return administratorPassword.equals(password);
			else
				return false;
		}
		catch (Exception e) 
		{
			logger.error("There was an error when we encrypted the password:" + e.getMessage(), e);
			return false;
		}
	}

	public static boolean getUsePasswordEncryption()
	{
		boolean usePasswordEncryption = false;
		try
		{
			usePasswordEncryption = Boolean.parseBoolean(getServerNodeProperty("usePasswordEncryption", true, "false"));
		}
		catch(Exception e)
		{
			logger.warn("Error parsing usePasswordEncryption:" + e.getMessage());
		}
		
		return usePasswordEncryption;
	}

	public static String getAdministratorEmail()
	{
	    return getProperty("administratorEmail");
	}

	public static String getDbRelease()
	{
	    return getProperty("dbRelease", "");
	}

	public static String getDbUser()
	{
	    return getProperty("dbUser", "");
	}

	public static String getDbPassword()
	{
	    return getProperty("dbPassword", "");
	}

	public static String getMasterServer()
	{
		return getServerNodeProperty("masterServer", true, "");
	}
   
	public static String getSlaveServer()
	{
		return getServerNodeProperty("slaveServer", true, "");
	}
	   
	public static String getBuildName()
	{
	    return getProperty("buildName", "");
	}
	
	public static String getAdminToolsPath()
	{
	    return getProperty("adminToolsPath", "");
	}
	
	public static String getDbScriptPath()
	{
	    return getProperty("dbScriptPath", "");
	}

	public static String getDigitalAssetUploadPath()
	{
	    return getServerNodeProperty("digitalAssetUploadPath", true, "" + getContextRootPath() + "uploads");
	}

	public static String getDisableAssetDeletionInWorkThread()
	{
	    return getServerNodeProperty("disableAssetDeletionInWorkThread", true, "false");
	}

	public static String getDisableAssetDeletionInLiveThread()
	{
	    return getServerNodeProperty("disableAssetDeletionInLiveThread", true, "false");
	}

	public static String getExtranetCookieTimeout()
	{
	    return getServerNodeProperty("extranetCookieTimeout", true, "1800");
	}
	
	public static String getWebServicesBaseUrl()
	{
		String webServicesBaseUrl =  getServerNodeProperty("webServicesBaseUrl", true, "" + getCmsFullBaseUrl() + "/services/");
		if(webServicesBaseUrl != null && !webServicesBaseUrl.startsWith("http"))
		{
			webServicesBaseUrl = "" + defaultScheme + "://127.0.0.1:" + defaultPort + "" + webServicesBaseUrl;
			logger.warn("Rewriting webServicesBaseUrl - now:" + webServicesBaseUrl);
		}
		return webServicesBaseUrl;
	}
	
	public static String getLivePublicationThreadClass() 
	{
		return getServerNodeProperty("livePublicationThreadClass", true, "org.infoglue.deliver.util.SelectiveLivePublicationThread");
	}

	public static String getPublicationThreadDelay()
	{
	    return getServerNodeProperty("publicationThreadDelay", true, "5000");
	}

	public static String getPathsToRecacheOnPublishing()
	{
	    return getServerNodeProperty("pathsToRecacheOnPublishing", true);
	}

	public static String getDisableTemplateDebug()
	{
	    return getServerNodeProperty("disableTemplateDebug", true, "false");
	}

	public static String getTree()
	{
	    return getServerNodeProperty("tree", true, "html");
	}

	public static String getTreeMode()
	{
	    return getServerNodeProperty("treemode", true, "dynamic");
	}

	public static String getDisableCustomIcons()
	{
	    return getServerNodeProperty("disableCustomIcons", true, "true");
	}

	public static String getWorkingStyleInformation()
	{
	    return getServerNodeProperty("workingStyleInformation", true, "color: #007900");
	}

	public static String getFinalStyleInformation()
	{
	    return getServerNodeProperty("finalStyleInformation", true, "color: #baaf00");
	}

	public static String getPublishStyleInformation()
	{
	    return getServerNodeProperty("publishStyleInformation", true, "color: #ba0000");
	}

	public static String getPublishedStyleInformation()
	{
	    return getServerNodeProperty("publishedStyleInformation", true, "");
	}
	
	public static String getPreviewDeliveryUrl()
	{
	    return getServerNodeProperty("previewDeliveryUrl", true);
	}

	public static String getStagingDeliveryUrl()
	{
	    return getServerNodeProperty("stagingDeliveryUrl", true);
	}

	public static String getEditionPageSize()
	{
		return getServerNodeProperty("edition.pageSize", true, "10");
	}
	
	public static String getContentTreeSort()
	{
		return getServerNodeProperty("content.tree.sort", true, "name");
	}

	private static Boolean allowLocalizedSortAndVisibilityProperties = null;
	public static Boolean getAllowLocalizedSortAndVisibilityProperties()
	{
		if(allowLocalizedSortAndVisibilityProperties == null)
		{
			try
			{
				allowLocalizedSortAndVisibilityProperties = false;
				ContentTypeDefinitionVO metaInfoCTDVO = ContentTypeDefinitionController.getController().getContentTypeDefinitionVOWithName("Meta info");
				if(metaInfoCTDVO != null)
				{
					List<ContentTypeAttribute> attributes =  ContentTypeDefinitionController.getController().getContentTypeAttributes(metaInfoCTDVO.getSchemaValue());
					for(ContentTypeAttribute attribute : attributes)
					{
						if(attribute.getName().equalsIgnoreCase("SortOrder") || attribute.getName().equalsIgnoreCase("HideInNavigation"))
						{
							allowLocalizedSortAndVisibilityProperties = true;
							break;
						}
					}
				}
			}
			catch (Exception e) 
			{
				logger.warn("Problem reading meta info fields: " + e.getMessage(), e);
			}
		}
		
		return allowLocalizedSortAndVisibilityProperties;
	}

	public static String getStructureTreeSort()
	{
		return getServerNodeProperty("structure.tree.sort", true, "name");
	}

	public static String getStructureTreeIsHiddenProperty()
	{
		return getServerNodeProperty("structure.tree.isHidden", true);
	}

	public static String getUseAccessRightsOnContentTree()
	{
		return getServerNodeProperty("content.tree.hideForbidden", true, "false");
	}

	public static String getUseAccessRightsOnStructureTree()
	{
		return getServerNodeProperty("structure.tree.hideForbidden", true, "false");
	}

	public static String getShowLanguageVariationsInStructureTree()
	{
		return getServerNodeProperty("showLanguageVariationsInStructureTree", true, "true");
	}

	public static String getEnforceRigidContentAccess()
	{
		return getEnforceRigidContentAccess(false);
	}
	
	public static String getEnforceRigidContentAccess(boolean skipHardCache)
	{
		if(enforceRigidContentAccess == null || skipHardCache)
		{
			enforceRigidContentAccess = getServerNodeProperty("enforceRigidContentAccess", true, "false");
		}
		
		return enforceRigidContentAccess;
	}

	public static String getDisableEmptyUrls()
	{
		return getServerNodeProperty("disableEmptyUrls", true, "yes");
	}

	public static String getCacheUpdateAction()
	{
		return getServerNodeProperty("cacheUpdateAction", true, "UpdateCache.action");
	}

	public static String getLogPath()
	{
		return getServerNodeProperty("logPath", true, "" + contextRootPath + "logs" + File.separator + applicationName + ".log");
	}

	public static String getLogTransactions()
	{
		return getServerNodeProperty("logTransactions", true, "false");
	}
	
	public static String getEnableExtranetCookies()
	{
		return getServerNodeProperty("enableExtranetCookies", true, "false");
	}
	
	public static String getUseBrowserLanguage()
	{
		return getServerNodeProperty("useBrowserLanguage", true, "false");
	}

	public static String getUseAlternativeBrowserLanguageCheck()
	{
		return getServerNodeProperty("useAlternativeBrowserLanguageCheck", true, "false");
	}
	
	public static String getCaseSensitiveRedirects()
	{
		return getServerNodeProperty("caseSensitiveRedirects", true, "false");
	}
	
	public static String getUseDNSNameInURI()
	{
		return getServerNodeProperty("useDNSNameInURI", true, "false");
	}

	public static String getWysiwygEditor()
	{
		return getServerNodeProperty("prefferedWYSIWYG", true, "ckeditor4");
	}

	public static String getPrefferedWYSIWYG()
	{
		return getServerNodeProperty("prefferedWYSIWYG", true, "ckeditor4");
	}

	public static String getDisableImageEditor()
	{
		return getServerNodeProperty("disableImageEditor", true, "false");
	}
	
	public static String getProtectContentTypes()
	{
		return getServerNodeProperty("protectContentTypes", true, "false");
	}

	public static String getProtectWorkflows()
	{
		return getServerNodeProperty("protectWorkflows", true, "false");
	}

	public static String getProtectCategories()
	{
		return getServerNodeProperty("protectCategories", true, "false");
	}

	public static String getHideProtectedProperties()
	{
		return getServerNodeProperty("hideProtectedProperties", true, "true");
	}

	public static String getInternalSearchEngine()
	{
		return getServerNodeProperty("internalSearchEngine", true, "lucene");
	}

	public static String getFastSearchIncludedContentTypes()
	{
		return getServerNodeProperty("fastSearchIncludedContentTypes", true, "Article,Image");
	}

	public static String getGACode()
	{
		return getServerNodeProperty("gaCode", true, "");
	}

	public static String getW3CValidationServiceUrl()
	{
		return getServerNodeProperty("w3cValidationServiceUrl", true, "http://validator.w3.org/check");
	}

	public static String getMaxRows()
	{
		return getServerNodeProperty("maxRows", true, "100");
	}

	public static Integer getMaxNumberOfAssetInSearches()
	{
		Integer maxNumberOfAssetInSearches = 50;
		String maxNumberOfAssetInSearchesString = getServerNodeProperty("maxNumberOfAssetInSearches", true, "50");
		try
		{
			maxNumberOfAssetInSearches = new Integer(maxNumberOfAssetInSearchesString);
		}
		catch (Exception e) 
		{
			logger.warn("Problem parsing maxNumberOfAssetInSearches:" + e.getMessage());
		}
		
		return maxNumberOfAssetInSearches;
	}

	public static String getComponentBindningAssetBrowser()
	{
		return getServerNodeProperty("componentBindningAssetBrowser", true, "default");
	}

	public static String getDefaultNumberOfYearsBeforeExpire()
	{
		return getDefaultNumberOfYearsBeforeExpire(false);
	}
	
	public static String getDefaultNumberOfYearsBeforeExpire(boolean skipHardCache)
	{
		if(defaultNumberOfYearsBeforeExpire == null || skipHardCache)
		{
			defaultNumberOfYearsBeforeExpire = getServerNodeProperty("defaultNumberOfYearsBeforeExpire", true, "50");
		}
		
		return defaultNumberOfYearsBeforeExpire;
	}
	public static String getDefaultNumberOfMonthsBeforeRedirectExpire(){
		return getDefaultNumberOfMonthsBeforeRedirectExpire(false);
	}
	public static String getDefaultNumberOfMonthsBeforeRedirectExpire(boolean skipHardCache){
		if(defaultNumberOfMonthsBeforeRedirectExpire == null || skipHardCache){
			defaultNumberOfMonthsBeforeRedirectExpire = getServerNodeProperty("defaultNumberOfMonthsBeforeRedirectExpire", true,"3");
		}
		return defaultNumberOfMonthsBeforeRedirectExpire;
	}

	public static int getDefaultNumberOfMonthsBeforeSystemRedirectExpire()
	{
		int expireMonths = 3;
		String expireMonthsString = getServerNodeProperty("defaultNumberOfMonthsBeforeSystemRedirectExpire", true, "3");

		try
		{
			expireMonths = Integer.parseInt(expireMonthsString);
		}
		catch (NumberFormatException ex)
		{
			logger.warn("Failed to parse number of months for system redirect expiration. Value " + expireMonthsString + ". Message: " + ex.getMessage());
		}

		return expireMonths;
	}

	public static String getEnableDateTimeDirectEditing()
	{
		return getServerNodeProperty("enableDateTimeDirectEditing", true, "false");
	}

	public static String getShowContentVersionFirst()
	{
		return getServerNodeProperty("showContentVersionFirst", true, "true");
	}
	
	public static String getShowComponentsFirst()
	{
		return getServerNodeProperty("showComponentsFirst", true, "true");
	}
	
	public static String getDecoratedPageInvoker()
	{
		return getServerNodeProperty("decoratedPageInvoker", true, "simple");
	}

	public static String getShowAllWorkflows()
	{
		return getServerNodeProperty("showAllWorkflows", true, "true");
	}
	
	public static String getIsPageCacheOn()
	{
	    return getServerNodeProperty("isPageCacheOn", true, "true");
	}

	public static String getEditOnSite()
	{
	    return getServerNodeProperty("editOnSite", true, "true");
	}

	public static String getUseSelectivePageCacheUpdate()
	{
	    return getServerNodeProperty("useSelectivePageCacheUpdate", true, "true");
	}

	public static String getExpireCacheAutomatically()
	{
	    return getServerNodeProperty("expireCacheAutomatically", true, "false");
	}

	public static String getCacheExpireInterval()
	{
	    return getServerNodeProperty("cacheExpireInterval", true, "1800");
	}

	public static String getDeliverRequestTimeout()
	{
	    return getServerNodeProperty("deliverRequestTimeout", true, "60000");
	}

	public static String getLiveDeliverRequestTimeout()
	{
	    return getServerNodeProperty("liveDeliverRequestTimeout", true, "60000");
	}

	public static boolean getKillLiveRequestWhichTimedout()
	{
		boolean killLiveRequestWhichTimedout = false;
		try
		{
			killLiveRequestWhichTimedout = Boolean.parseBoolean(getServerNodeProperty("killLiveRequestWhichTimedout", true, "false"));
		}
		catch(Exception e)
		{
			logger.warn("Error parsing killLiveRequestWhichTimedout:" + e.getMessage());
		}
		
		return killLiveRequestWhichTimedout;
	}

	public static Boolean getUseSimpleComponentDialog()
	{
		boolean useSimpleComponentDialog = false;
		try
		{
			useSimpleComponentDialog = Boolean.parseBoolean(getServerNodeProperty("useSimpleComponentDialog", true, "true"));
		}
		catch(Exception e)
		{
			logger.warn("Error parsing useSimpleComponentDialog:" + e.getMessage());
		}
		
		return useSimpleComponentDialog;
	}

	public static Boolean getHideAccessRightsIfNotAllowedToManage()
	{
		boolean hideAccessRightsIfNotAllowedToManage = false;
		try
		{
			hideAccessRightsIfNotAllowedToManage = Boolean.parseBoolean(getServerNodeProperty("hideAccessRightsIfNotAllowedToManage", true, "true"));
		}
		catch(Exception e)
		{
			logger.warn("Error parsing useSimpleComponentDialog:" + e.getMessage());
		}
		
		return hideAccessRightsIfNotAllowedToManage;
	}

	public static Boolean getOnlyAllowFolderType()
	{
		boolean onlyAllowFolderType = true;
		try
		{
			onlyAllowFolderType = Boolean.parseBoolean(getServerNodeProperty("onlyAllowFolderType", true, "true"));
		}
		catch(Exception e)
		{
			logger.warn("Error parsing onlyAllowFolderType:" + e.getMessage());
		}
		
		return onlyAllowFolderType;
	}

	public static Boolean getSkipResultDialogIfPossible()
	{
		boolean skipResultDialogIfPossible = true;
		try
		{
			skipResultDialogIfPossible = Boolean.parseBoolean(getServerNodeProperty("skipResultDialogIfPossible", true, "true"));
		}
		catch(Exception e)
		{
			logger.warn("Error parsing skipResultDialogIfPossible:" + e.getMessage());
		}
		
		return skipResultDialogIfPossible;
	}
	
	public static boolean getEnableIfModifiedHeaders()
	{
		String enableIfModifiedHeaders = getServerNodeProperty("enableIfModifiedHeaders", true, "true");
		boolean enableIfModifiedHeadersBool = true;
	
		if (enableIfModifiedHeaders.equalsIgnoreCase("false")) {
			enableIfModifiedHeadersBool = false;
		}
		return enableIfModifiedHeadersBool;
	}
	
	public static Boolean getUseHashCodeInCaches()
	{
		return getUseHashCodeInCaches(false);
	}
	
	public static Boolean getUseHashCodeInCaches(boolean skipHardCache)
	{
		if(useHashCodeInCaches == null || skipHardCache)
		{
			boolean newUseHashCodeInCaches = false;
			try
			{
				newUseHashCodeInCaches = Boolean.parseBoolean(getServerNodeProperty("useHashCodeInCaches", true, "false", true));
			}
			catch(Exception e)
			{
				logger.warn("Error parsing useHashCodeInCaches:" + e.getMessage());
			}
			useHashCodeInCaches = newUseHashCodeInCaches;
		}
		
		return useHashCodeInCaches;
	}

	public static Boolean getUseSynchronizationOnCaches()
	{
		return getUseSynchronizationOnCaches(false);
	}
	
	public static Boolean getUseSynchronizationOnCaches(boolean skipHardCache)
	{
		if(useSynchronizationOnCaches == null || skipHardCache)
		{
			boolean newUseSynchronizationOnCaches = false;
			try
			{
				newUseSynchronizationOnCaches = Boolean.parseBoolean(getServerNodeProperty("useSynchronizationOnCaches", true, "true", true));
			}
			catch(Exception e)
			{
				logger.warn("Error parsing useSynchronizationOnCaches:" + e.getMessage());
			}
			
			logger.info("Slow query for newUseSynchronizationOnCaches:" + newUseSynchronizationOnCaches);
			useSynchronizationOnCaches = newUseSynchronizationOnCaches;
		}

		return useSynchronizationOnCaches;
	}

	public static String getUseHighLoadLimiter()
	{
	    return getServerNodeProperty("useHighLoadLimiter", true, "false");
	}

	public static String getMaxActiveRequests()
	{
	    return getServerNodeProperty("maxActiveRequests", true, "50");
	}

	public static String getMaxRequestTime()
	{
	    return getServerNodeProperty("maxRequestTime", true, "5000");
	}

	public static String getSessionTimeout()
	{
	    return getServerNodeProperty("session.timeout", true, "1800");
	}

	public static String getCompressPageCache()
	{
	    return getServerNodeProperty("compressPageCache", true, "true");
	}

	public static String getCompressPageResponse()
	{
	    return getServerNodeProperty("compressPageResponse", true, "true");
	}

	public static String getSiteNodesToRecacheOnPublishing()
	{
	    return getServerNodeProperty("siteNodesToRecacheOnPublishing", true, "");
	}

	public static String getRecachePublishingMethod()
	{
	    return getServerNodeProperty("recachePublishingMethod", true, "");
	}

	public static String getRecacheUrl()
	{
	    return getServerNodeProperty("recacheUrl", true, "");
	}

	public static String getUseUpdateSecurity()
	{
	    return getServerNodeProperty("useUpdateSecurity", true, "true");
	}
	
	public static String getAllowedAdminIP()
	{
	    return getServerNodeProperty("allowedAdminIP", true, "");
	}

	public static boolean getAllowXForwardedIPCheck()
	{
	    String allowXForwardedIPCheck = getServerNodeProperty("allowXForwardedIPCheck", true, "false");

	    return Boolean.parseBoolean(allowXForwardedIPCheck);
	}
	
	
	public static String getPageKey()
	{
	    return getServerNodeProperty("pageKey", true, "");
	}

	public static String getComponentKey()
	{
	    return getServerNodeProperty("componentKey", true, "");
	}

	public static String getCmsFullBaseUrl()
	{
		String cmsFullBaseUrl = getServerNodeProperty("cmsFullBaseUrl", true);
		if(cmsFullBaseUrl == null || cmsFullBaseUrl.equals(""))
		{
			cmsFullBaseUrl = "" + defaultScheme + "://127.0.0.1:" + defaultPort + "" + getCmsBaseUrl();
		}
		else if(cmsFullBaseUrl != null && !cmsFullBaseUrl.startsWith("http"))
		{
			cmsFullBaseUrl = "" + defaultScheme + "://127.0.0.1:" + defaultPort + "" + getCmsBaseUrl();
		}
		
		return cmsFullBaseUrl;
	}

	public static String getCmsBaseUrl()
	{
	    return getServerNodeProperty("cmsBaseUrl", true, "");
	}

	public static String getComponentEditorUrl()
	{
	    return getServerNodeProperty("componentEditorUrl", true, "");
	}

	public static String getComponentRendererUrl()
	{
	    return getServerNodeProperty("componentRendererUrl", true, "");
	}

	public static String getRecacheWorkingUrl()
	{
	    return getProperty("recacheWorkingUrl", "@recacheWorkingUrl@");
	}

	public static String getComponentRendererAction()
	{
	    return getServerNodeProperty("componentRendererAction", true, "ViewPage!renderDecoratedPage.action");
	}

	public static String getEditOnSiteUrl()
	{
	    return getServerNodeProperty("editOnSiteUrl", true, "");
	}

	public static String getUseFreeMarker()
	{
	    return getServerNodeProperty("useFreeMarker", true, "false");
	}

	public static String getWebServerAddress()
	{
	    return getServerNodeProperty("webServerAddress", true, "");
	}

	public static String getApplicationBaseAction()
	{
	    return getServerNodeProperty("applicationBaseAction", true, "");
	}

	public static String getDigitalAssetBaseUrl()
	{
	    return getServerNodeProperty("digitalAssetBaseUrl", true, "");
	}

	public static String getImagesBaseUrl()
	{
	    return getServerNodeProperty("imagesBaseUrl", true, "");
	}

	public static String getDigitalAssetPath()
	{
	    return getServerNodeProperty("digitalAssetPath", true, "" + contextRootPath + "digitalAssets");
	}

	public static String getDigitalAssetPath0()
	{
		return getDigitalAssetPath0(false);
	}
	
	public static String getDigitalAssetPath0(boolean skipHardCache)
	{
		if(digitalAssetPath0 == null || skipHardCache)
		{
			digitalAssetPath0 = getServerNodeProperty("digitalAssetPath.0", true, "" + contextRootPath + "digitalAssets");
		}
		
	    return digitalAssetPath0;
	}

	public static String getEnableDiskAssets()
	{
	    return getServerNodeProperty("enableDiskAssets", true, "false");
	}

	public static String getEnableNiceURI()
	{
		return getEnableNiceURI(false);
	}
	
	public static String getEnableNiceURI(boolean skipHardCache)
	{
		if(enableNiceURI == null || skipHardCache)
		{
			String value = null;
			if(!getOperatingMode().equals("3"))
				value = getServerNodeProperty("enableNiceURIInWorking", true, "true");
			else
				value = getServerNodeProperty("enableNiceURI", true, "true");
		
			enableNiceURI = value;
		}
		
		return enableNiceURI;
	}

	public static String getNiceURIDisableNiceURIForContent()
	{
		return getServerNodeProperty("niceURIDisableNiceURIForContent", true, "false");
	}

	public static String getEnableNiceURIForLanguage()
	{
		return getServerNodeProperty("enableNiceURIForLanguage", true, "false");
	}

	public static String getNiceURIEncoding()
	{
		return getNiceURIEncoding(false);
	}
	
	public static String getNiceURIEncoding(boolean skipHardCache)
	{
		if(niceURIEncoding == null || skipHardCache)
		{
			niceURIEncoding = getServerNodeProperty("niceURIEncoding", true, "UTF-8");
		}
		
	    return niceURIEncoding;
	}

	public static String getNiceURIAttributeName()
	{
	    return getServerNodeProperty("niceURIAttributeName", true, "NiceURIName");
	}

	public static String getNiceURIFallbackAttributeName()
	{
	    return getServerNodeProperty("niceURIFallbackAttributeName", true, "NavigationTitle");
	}

	public static String getRequestArgumentDelimiter()
	{
	    return getServerNodeProperty("requestArgumentDelimiter", true, "&");
	}

	public static String getErrorUrl()
	{
	    return getServerNodeProperty("errorUrl", true);
	}

	public static String getErrorBusyUrl()
	{
	    return getServerNodeProperty("errorBusyUrl", true);
	}

	public static String getExternalThumbnailGeneration()
	{
	    return getServerNodeProperty("externalThumbnailGeneration", true);
	}

	public static String getURIEncoding()
	{
	    return getServerNodeProperty("URIEncoding", true, "UTF-8");
	}

	public static String getWorkflowEncoding()
	{
	    return getServerNodeProperty("workflowEncoding", true, "UTF-8");
	}

	public static String getFormsEncoding()
	{
	    return getServerNodeProperty("formsEncoding", true, "UTF-8");
	}

	public static String getUploadFromEncoding()
	{
		return getServerNodeProperty("uploadFromEncoding", true, "ISO-8859-1");
	}

	public static String getUploadToEncoding()
	{
		return getServerNodeProperty("uploadToEncoding", true, "UTF-8");
	}

	public static String getAssetKeyFromEncoding()
	{
		return getServerNodeProperty("assetKeyFromEncoding", true, "ISO-8859-1");
	}

	public static String getAssetKeyToEncoding()
	{
		return getServerNodeProperty("assetKeyToEncoding", true, "UTF-8");
	}

	public static String getUseShortTableNames()
	{
	    return getServerNodeProperty("useShortTableNames", true, "false");
	}

	public static String getUseImprovedContentCategorySearch()
	{
		return getUseImprovedContentCategorySearch(false);
	}
	
	public static String getUseImprovedContentCategorySearch(boolean skipHardCache)
	{
		if(useImprovedContentCategorySearch == null || skipHardCache)
		{
			useImprovedContentCategorySearch = getServerNodeProperty("useImprovedContentCategorySearch", true, "true");
		}
		
	    return useImprovedContentCategorySearch;
	}

	public static String getDatabaseEngine()
	{
	    return getServerNodeProperty("databaseEngine", true, null);
	}

	public static String getInfoGlueVersion()
	{
	    return getServerNodeProperty("infoGlueVersion", true, "3.5.1.0");
	}

	public static String getInfoGlueDBVersion()
	{
	    return getServerNodeProperty("infoGlueDBVersion", true, "3.0");
	}

	public static String getInfoGlueVersionReleaseDate()
	{
	    return getServerNodeProperty("infoGlueVersionReleaseDate", true, "2016-11-24");
	}

	public static String getLogDatabaseMessages()
	{
	    return getServerNodeProperty("logDatabaseMessages", true, "false");
	}

	public static String getStatisticsEnabled()
	{
	    return getServerNodeProperty("statistics.enabled", true, "false");
	}

	public static String getPublicationListLogPath()
	{
	    return getServerNodeProperty("publicationListLogPath", true, "" + contextRootPath + "logs");
	}

	public static String getStatisticsLogPath()
	{
	    return getServerNodeProperty("statisticsLogPath", true, "" + contextRootPath + "logs");
	}

	public static String getStatisticsLogOneFilePerDay()
	{
	    return getServerNodeProperty("statisticsLogOneFilePerDay", true, "false");
	}

	public static String getStatisticsLogger()
	{
	    return getServerNodeProperty("statisticsLogger", true, "W3CExtendedLogger");
	}

	public static String getEnablePortal()
	{
		return getEnablePortal(false);
	}
	
	public static String getEnablePortal(boolean skipHardCache)
	{
		if(enablePortal == null || skipHardCache)
		{
			enablePortal = getServerNodeProperty("enablePortal", true, "true");
		}
		
	    return enablePortal;
	}

	public static String getPortletBase()
	{
	    return getServerNodeProperty("portletBase", true);
	}

	public static String getMailSmtpHost()
	{
	    return getServerNodeProperty("mail.smtp.host", true);
	}

	public static String getMailSmtpPort()
	{
	    return getServerNodeProperty("mail.smtp.port", true);
	}

	public static String getMailSmtpAuth()
	{
	    return getServerNodeProperty("mail.smtp.auth", true);
	}

	public static String getMailSmtpUser()
	{
	    return getServerNodeProperty("mail.smtp.user", true);
	}

	public static String getMailSmtpPassword()
	{
	    return getServerNodeProperty("mail.smtp.password", true);
	}

	public static String getMailContentType()
	{
	    return getServerNodeProperty("mail.contentType", true, "text/html");
	}
	
	public static String getSystemEmailSender()
	{
	    return getServerNodeProperty("systemEmailSender", true);
	}

	public static String getWarningEmailReceiver()
	{
	    return getServerNodeProperty("warningEmailReceiver", true);
	}

	public static String getEmailRecipientLimit()
	{
	    return getServerNodeProperty("emailRecipientLimit", true, "-1");
	}

	public static String getExportFormat()
	{
	    return getServerNodeProperty("exportFormat", true, "3");
	}

	public static String getHelpUrl()
	{
	    return getServerNodeProperty("helpUrl", true);
	}
	
	public static String getSendToolbarKeyAsParameter()
	{
	    return getServerNodeProperty("sendToolbarKeyAsParameter", true, "true");
	}
	
	public static String getInfoButtonLabel(Locale locale)
	{
		if(getSwitchInfoButtonLabelToThisHelpUrl(locale) != null && !getSwitchInfoButtonLabelToThisHelpUrl(locale).equals(""))
			return getServerNodeProperty("infoButtonLabel", false, LabelController.getController(locale).getString("tool.common.helpButton.label"));
		else
			return getServerNodeProperty("infoButtonLabel", true, LabelController.getController(locale).getString("header.link.versionInfo"));
	}

	public static String getSwitchInfoButtonLabelToThisHelpUrl(Locale locale)
	{
	    return getServerNodeProperty("switchInfoButtonLabelToThisHelpUrl", true, "");
	}

	public static String getContextBasedHelpUrlBase(Locale locale)
	{
	    return getServerNodeProperty("contextBasedHelpUrlBase", true, "" + getHelpUrl());
	}

	public static Boolean getUseContextBasedHelp()
	{
		String useContextBasedHelp = getServerNodeProperty("useContextBasedHelp", true, "true");
		
		return Boolean.parseBoolean(useContextBasedHelp);
	}

	public static String getContentVersionEditorFlavour() 
	{
		return getServerNodeProperty("contentVersionEditorFlavour", true, "v3default");
	}

	public static String getHeaderHTML()
	{
	    return getServerNodeDataProperty(null, "headerHTML", true, "");
	}

	public static String getAboutHTML(Locale locale)
	{
		String helpUrl = getHelpUrl();
		String systemAdminEmail = getWarningEmailReceiver();
		
		String aboutHTML = "" + LabelController.getController(locale).getString("tool.common.about.html", helpUrl, systemAdminEmail);
	    String html = getServerNodeDataProperty(null, "aboutHTML", true, aboutHTML);
	    if(html == null || html.equals(""))
	    	html = aboutHTML;
	    return html;
	}

	public static String getErrorTitle(Locale locale)
	{
		String errorTitle = "" + LabelController.getController(locale).getString("tool.common.error.title");
		String html = getServerNodeProperty("errorTitle", true, errorTitle);
		if(html == null || html.equals(""))
	    	html = errorTitle;
	    return html;
	}

	public static String getErrorHTML(Locale locale)
	{
		String errorHtml = "" + LabelController.getController(locale).getString("tool.common.error.html");
	    String html = getServerNodeDataProperty(null, "errorHTML", true, errorHtml);
	    if(html == null || html.equals(""))
	    	html = errorHtml;
	    return html;
	}

	public static String getProtectDeliverWorking()
	{
	    return getServerNodeProperty("protectDeliverWorking", true, "false");
	}

	public static String getProtectDeliverPreview()
	{
	    return getServerNodeProperty("protectDeliverPreview", true, "false");
	}

	public static String getForceIdentityCheck()
	{
		return getServerNodeProperty("forceIdentityCheck", true, "false");
	}

	public static String getNumberOfVersionsToKeepDuringClean()
	{
		return getServerNodeProperty("numberOfVersionsToKeepDuringClean", true, "-1");
	}

	public static String getKeepOnlyOldPublishedVersionsDuringClean()
	{
		return getServerNodeProperty("keepOnlyOldPublishedVersionsDuringClean", true, "true");
	}

	public static Long getMinimumTimeBetweenVersionsDuringClean()
	{
		long value = -1;
		
		String minimumTimeBetweenVersionsDuringClean = getServerNodeProperty("minimumTimeBetweenVersionsDuringClean", true, "-1");
		try
		{
			value = new Long(minimumTimeBetweenVersionsDuringClean).longValue();
		}
		catch (Exception e) 
		{
			logger.warn("Problem getting minimumTimeBetweenVersionsDuringClean:" + e.getMessage());
		}
		
		return value;
	}

	public static String getAssetUploadTransformationsSettings()
	{
		return getServerNodeDataProperty(null, "assetUploadTransformationsSettings", true, "");
	}

	public static String getAllowPublicationEventFilter()
	{
	    return getServerNodeProperty("allowPublicationEventFilter", true, "false");
	}

	public static String getUseApprovalFlow()
	{
	    return getServerNodeProperty("useApprovalFlow", true, "true");
	}

	public static String getAutoShowApprovalButtons()
	{
	    return getServerNodeProperty("autoShowApprovalButtons", true, "true");
	}

	public static String getSkipVersionComment()
	{
	    return getServerNodeProperty("skipVersionComment", true, "false");
	}

	public static String getDefaultPublicationEventFilter()
	{
	    return getServerNodeProperty("defaultPublicationEventFilter", true, "all");
	}

	public static String getMetaInfoAttributesToShowInCreatePageDialog()
	{
	    return getServerNodeProperty("metaInfoAttributesToShowInCreatePageDialog", true, "Title,NavigationTitle,NiceURIName");
	}

	public static String getPreferredLanguageCode(String userName)
	{
        String langCode = getPropertySet().getString("principal_" + userName + "_languageCode");
        return (langCode == null ? "en" : langCode);
	}

	public static String getPreferredToolName(String userName)
	{
		String preferredToolName = getPropertySet().getString("principal_" + userName + "_defaultToolName");
	    if(preferredToolName == null || preferredToolName.equals(""))
	    	preferredToolName = "StructureTool";

	    return preferredToolName;
	}

	public static String getDefaultGUI(String userName)
	{
		String defaultGUI = getPropertySet().getString("principal_" + userName + "_defaultGUI");
	    
		return (defaultGUI == null ? "default" : defaultGUI);
	}

	public static String getDefaultTreeTitleField(String userName)
	{
		String defaultGUI = getPropertySet().getString("principal_" + userName + "_defaultTreeTitleField");
	    
		return (defaultGUI == null ? "NavigationTitle" : defaultGUI);
	}

	public static String getToolbarVariant(String userName)
	{
		String toolbarVariant = getPropertySet().getString("principal_" + userName + "_toolbarVariant");
	    
		return (toolbarVariant == null ? "compact" : toolbarVariant);
	}
	
	public static String getTheme(String userName)
	{
		String theme = getPropertySet().getString("principal_" + userName + "_theme");
		
		return (theme == null ? getDefaultSystemTheme() : theme);
	}

	public static String getDefaultSystemTheme()
	{
		String theme = getServerNodeProperty("defaultSystemTheme", true, "Default");

		return (theme == null || !themeExists(theme) ? "Default" : theme);
	}

	public static boolean themeExists(String theme)
	{
		return ThemeController.getController().getAvailableThemes().contains(theme);
	}

	public List getAvailableThemes()
	{
		return ThemeController.getController().getAvailableThemes();
	}

	public List<List<String>> getAvailableThemesAsMap()
	{
		List<List<String>> list = new ArrayList<List<String>>();
		
		for(String themeName : (List<String>)ThemeController.getController().getAvailableThemes())
		{
			List list2 = new ArrayList<String>();
			list2.add(themeName);
			list2.add(themeName);
			list.add(list2);
		}
	
		return list;
	}

	public static String getThemeFile(String theme, String filePath)
	{
		String themeFilePath = "css" + filePath;
		
		if(theme != null)
		{
			File skinsFile = new File(CmsPropertyHandler.getContextRootPath() + File.separator + "css" + File.separator + "skins" + File.separator + theme + File.separator + filePath);
			if(skinsFile != null && skinsFile.exists())
				return "css" + File.separator + "skins" + File.separator + theme + File.separator + filePath;
			else
				return null;
		}
		else
			return themeFilePath;
	}

	public static String getDisableEditOnSightToolbar()
	{
		String disableEditOnSightToolbar = getServerNodeProperty("disableEditOnSightToolbar", true, "false");
		/*
		if(getPrefferedWYSIWYG().equalsIgnoreCase("fckeditor2"))
			disableEditOnSightToolbar = "true";
		*/
		return disableEditOnSightToolbar;
	}

	public static boolean getPersonalDisableEditOnSightToolbar(String userName)
	{
		String systemDisableEditOnSightToolbar = getDisableEditOnSightToolbar();
		if(systemDisableEditOnSightToolbar.equals("true"))
		{
			return true;
		}
		else
		{
			String disableEditOnSightToolbar = getPropertySet().getString("principal_" + userName + "_disableEditOnSightToolbar");
			return (disableEditOnSightToolbar == null || !disableEditOnSightToolbar.equals("true") ? false : true);
		}
	}

	public static String getShowInlinePropertiesIcon()
	{
	    return getServerNodeProperty("showInlinePropertiesIcon", true, "true");
	}

	public static String getUseDoubleClickOnTextToInlineEdit()
	{
	    return getServerNodeProperty("useDoubleClickOnTextToInlineEdit", true, "true");
	}

	public static String getPreferredRepositoryId(String userName)
	{
	    return getPropertySet().getString("principal_" + userName + "_defaultRepositoryId");
	}

	public static String getPropertiesParser()
	{
	    return getServerNodeProperty("propertiesParser", false, "xpp3");
	}

	public static String getAllowCrossSiteSubmitToPublish()
	{
        return getServerNodeProperty("allowCrossSiteSubmitToPublish", true, "false");
	}

	public static String getEncodeValidateUrl()
	{
        return getServerNodeProperty("encodeValidateUrl", true, "false");
	}

	public static String getEncodeCasServiceUrl()
	{
        return getServerNodeProperty("encodeCasServiceUrl", true, "true");
	}

	public static String getAllowOverrideModifyer()
	{
	    return getServerNodeProperty("allowOverrideModifyer", true, "true");
	}

	public static String getSetDerivedLastModifiedInLive()
	{
		return getSetDerivedLastModifiedInLive(false);
	}
	
	public static String getSetDerivedLastModifiedInLive(boolean skipHardCache)
	{
		if(setDerivedLastModifiedInLive == null || skipHardCache)
		{
			setDerivedLastModifiedInLive = getServerNodeProperty("setDerivedLastModifiedInLive", true, "true");
		}
		
		return setDerivedLastModifiedInLive;
	}

	public static Integer getMaxNumberOfVersionsForDerivedLastModifiedInLive()
	{
		Integer max = 50;
		try
		{
			max = new Integer(getServerNodeProperty("maxNumberOfVersionsForDerivedLastModifiedInLive", true, "50"));
		}
		catch (Exception e) 
		{
			logger.error("Problem parsing maxNumberOfVersionsForDerivedLastModifiedInLive:" + e.getMessage());
		}
		return max;
	}

	public static Boolean getDoNotUseTrashcanForRepositories()
	{
		boolean doNotUseTrashcanForRepositories = true;
		try
		{
			doNotUseTrashcanForRepositories = Boolean.parseBoolean(getServerNodeProperty("doNotUseTrashcanForRepositories", true, "false"));
		}
		catch(Exception e)
		{
			logger.warn("Error parsing doNotUseTrashcanForRepositories:" + e.getMessage());
		}
		
		return doNotUseTrashcanForRepositories;
	}
	
	public static boolean getDuplicateAssetsBetweenVersions()
	{
		String duplicateAssetsBetweenVersions = getServerNodeProperty("duplicateAssetsBetweenVersions", true, "false");
		
		return Boolean.parseBoolean(duplicateAssetsBetweenVersions);
	}

	public static String getWYSIWYGToolbarComboPreviewCSS()
	{
		String WYSIWYGToolbarComboPreviewCSS = getServerNodeDataProperty(null, "WYSIWYGToolbarComboPreviewCSS", true, "p, div, h1, h2, h3, h4, h5, h6, pre, address { font-family: Verdana, Arial, Sans serif; font-size: 10px; font-style: normal; font-weight: normal; }");
		if(WYSIWYGToolbarComboPreviewCSS == null || WYSIWYGToolbarComboPreviewCSS.equals(""))
			WYSIWYGToolbarComboPreviewCSS = "p, div, h1, h2, h3, h4, h5, h6, pre, address { font-family: Verdana, Arial, Sans serif; font-size: 10px; font-style: normal; font-weight: normal; }";

		return WYSIWYGToolbarComboPreviewCSS;
	}

	public static String getWYSIWYGEditorAreaCSS()
	{
		return getServerNodeDataProperty(null, "WYSIWYGEditorAreaCSS", true, "");
	}

	public static List getInternalDeliveryUrls()
	{
		List urls = new ArrayList();
		
		InetAddress localAddress = null;
		try
		{
			localAddress = InetAddress.getLocalHost();
			logger.info("localAddress2:" + localAddress.getHostAddress());
		}
		catch (Exception e) 
		{
			e.printStackTrace();
		}
		
	    String internalDeliverUrlsString = CmsPropertyHandler.getServerNodeDataProperty(null, "internalDeliveryUrls", true, null);
	    if(internalDeliverUrlsString != null && !internalDeliverUrlsString.equals(""))
		{
	    	try
			{
	    		Properties properties = new Properties();
				properties.load(new ByteArrayInputStream(internalDeliverUrlsString.getBytes("UTF-8")));

				int i = 0;
				String deliverUrl = null;
				while((deliverUrl = properties.getProperty("" + i)) != null)
				{ 
					logger.info("deliverUrl:" + deliverUrl);
					if(deliverUrl.startsWith("unless["))
					{
						String unlessIP = deliverUrl.substring(7, deliverUrl.indexOf("]"));
						logger.info("unlessIP:" + unlessIP);
						if(localAddress == null || !localAddress.getHostAddress().equals(unlessIP))
						{
							urls.add(deliverUrl.substring(deliverUrl.indexOf("=") + 1));
							logger.info("Adding url:" + deliverUrl.substring(deliverUrl.indexOf("=") + 1));							
						}
						else
							logger.info("Not adding url:" + deliverUrl + " as it was ruled not to..");
					}
					else
					{
						urls.add(deliverUrl);
					}
					
					i++;
				}	

			}	
			catch(Exception e)
			{
			    logger.error("Error loading properties from string. Reason:" + e.getMessage());
			}
		}
	    else
	    {
			int i = 0;
			String deliverUrl = null;
			while((deliverUrl = CmsPropertyHandler.getProperty("internalDeliverUrl." + i)) != null)
			{ 
				if(deliverUrl.indexOf("@") == -1)
				{
					logger.info("internalDeliverUrl:" + deliverUrl);
					if(!deliverUrl.startsWith("http"))
					{
						deliverUrl = "" + defaultScheme + "://127.0.0.1:" + defaultPort + "" + deliverUrl;
					}
					logger.info("internalDeliverUrl:" + deliverUrl);
						
					urls.add(deliverUrl);
				}
				i++;
			}	
	    }

	    return urls;
	}

	public static List getPublicDeliveryUrls()
	{
		List urls = new ArrayList();
		
	    String publicDeliverUrlString = CmsPropertyHandler.getServerNodeDataProperty(null, "publicDeliveryUrls", true, null);
	    if(publicDeliverUrlString != null && !publicDeliverUrlString.equals(""))
		{
	    	try
			{
	    		Properties properties = new Properties();
				properties.load(new ByteArrayInputStream(publicDeliverUrlString.getBytes("UTF-8")));

				int i = 0;
				String deliverUrl = null;
				while((deliverUrl = properties.getProperty("" + i)) != null)
				{ 
					urls.add(deliverUrl);
					i++;
				}

			}	
			catch(Exception e)
			{
			    logger.error("Error loading properties from string. Reason:" + e.getMessage());
				e.printStackTrace();
			}
		}
	    else
	    {
			int i = 0;
			String deliverUrl = null;
			while((deliverUrl = CmsPropertyHandler.getProperty("publicDeliverUrl." + i)) != null)
			{ 
				if(deliverUrl.indexOf("@") == -1)
				{
					logger.info("deliverUrl:" + deliverUrl);
					if(!deliverUrl.startsWith("http"))
					{
						deliverUrl = "" + defaultScheme + "://127.0.0.1:" + defaultPort + "" + deliverUrl;
					}
					logger.info("deliverUrl:" + deliverUrl);
						
					urls.add(deliverUrl);
				}
				
				i++;
			}	
	    }
	    
	    return urls;
	}

	public static Map<String, DeploymentServerBean> getDeploymentServers()
	{
		Map<String, DeploymentServerBean> deploymentServers = new HashMap<String, DeploymentServerBean>();
		
	    String deploymentServersString = CmsPropertyHandler.getServerNodeDataProperty(null, "deploymentServers", true, null);
	    if(deploymentServersString != null && !deploymentServersString.equals(""))
		{
	    	try
			{
	    		Properties properties = new Properties();
				properties.load(new ByteArrayInputStream(deploymentServersString.getBytes("UTF-8")));

				int i = 0;
				String deploymentServerName = null;
				while((deploymentServerName = properties.getProperty("" + i)) != null)
				{
					String url = properties.getProperty("" + i + ".url");
					String user = properties.getProperty("" + i + ".user");
					String password = properties.getProperty("" + i + ".password");
					
					if(url == null)
						throw new Exception("Missing url-property for " + deploymentServerName + " (index: " + i + ")");
					if(user == null)
						throw new Exception("Missing user-property for " + deploymentServerName + " (index: " + i + ")");
					
					DeploymentServerBean dsb = new DeploymentServerBean(deploymentServerName, url, user, password);
					deploymentServers.put(deploymentServerName, dsb);
					i++;
				}	
			}	
			catch(Exception e)
			{
			    logger.error("Error loading properties from string. Reason:" + e.getMessage());
				e.printStackTrace();
			}
		}
	    
	    return deploymentServers;
	}

	public static Map<String,VersionControlServerBean> getVCServers()
	{
		Map<String,VersionControlServerBean> servers = new HashMap<String,VersionControlServerBean>();
		
	    String vcServersString = CmsPropertyHandler.getServerNodeDataProperty(null, "vcServers", true, null);
	    if(vcServersString != null && !vcServersString.equals(""))
		{
	    	try
			{
	    		Properties properties = new Properties();
				properties.load(new ByteArrayInputStream(vcServersString.getBytes("UTF-8")));

				int i = 0;
				String vcServerName = null;
				while((vcServerName = properties.getProperty("" + i)) != null)
				{
					String host = properties.getProperty("" + i + ".host");
					String path = properties.getProperty("" + i + ".path");
					String module = properties.getProperty("" + i + ".module");
					String user = properties.getProperty("" + i + ".user");
					String password = properties.getProperty("" + i + ".password");
					String type = properties.getProperty("" + i + ".type");
					String port = properties.getProperty("" + i + ".port");
					
					if(host == null)
						throw new Exception("Missing host-property for " + vcServerName + " (index: " + i + ")");
					if(path == null)
						throw new Exception("Missing path-property for " + vcServerName + " (index: " + i + ")");
					if(module == null)
						throw new Exception("Missing module-property for " + vcServerName + " (index: " + i + ")");
					if(user == null)
						throw new Exception("Missing user-property for " + vcServerName + " (index: " + i + ")");
					if(type == null)
						throw new Exception("Missing type-property for " + vcServerName + " (index: " + i + ")");
					
					VersionControlServerBean vcb = new VersionControlServerBean(vcServerName, host, path, module, user, password, type, port);
					servers.put(vcServerName, vcb);
					i++;
				}	

			}	
			catch(Exception e)
			{
			    logger.error("Error loading properties from string. Reason:" + e.getMessage());
			}
		}
	    
	    return servers;
	}

	public static List<Locale> getToolLocales()
	{
		List toolLocales = new ArrayList();
		
	    String toolLanguagesString = CmsPropertyHandler.getServerNodeDataProperty(null, "toolLanguages", true, null);
	    if(toolLanguagesString != null && !toolLanguagesString.equals(""))
		{
	    	try
			{
	    		Properties properties = new Properties();
				properties.load(new ByteArrayInputStream(toolLanguagesString.getBytes("UTF-8")));

			    int index = 0;
			    String languageCode = properties.getProperty("" + index);
			    while(languageCode != null)
			    {
			        Locale locale = new java.util.Locale(languageCode);
			        if(locale != null)
			            toolLocales.add(locale);
			        
			        index++;
			        languageCode = properties.getProperty("" + index);
			    }

			}	
			catch(Exception e)
			{
			    logger.error("Error loading properties from string. Reason:" + e.getMessage());
				e.printStackTrace();
			}
		}
	    else
	    {
	    	int index = 0;
		    String languageCode = CmsPropertyHandler.getProperty(index + ".toolLanguageCode");
		    while(languageCode != null)
		    {
		        Locale locale = new java.util.Locale(languageCode);
		        if(locale != null)
		            toolLocales.add(locale);
		        
		        index++;
		        languageCode = CmsPropertyHandler.getProperty(index + ".toolLanguageCode");
		    }
	    }

	    return toolLocales;
	}

	public static Map getCustomContentTypeIcons()
	{
		Map customContentTypeIcons = new HashMap();
		
	    String customContentTypeIconsString = CmsPropertyHandler.getServerNodeDataProperty(null, "customContentTypeIcons", true, null);
	    if(customContentTypeIconsString != null && !customContentTypeIconsString.equals(""))
		{
	    	try
			{
	    		Properties properties = new Properties();
				properties.load(new ByteArrayInputStream(customContentTypeIconsString.getBytes("UTF-8")));
				customContentTypeIcons.putAll(properties);
			}	
			catch(Exception e)
			{
			    logger.error("Error loading properties from string. Reason:" + e.getMessage());
				e.printStackTrace();
			}
		}
	    
	    return customContentTypeIcons;
	}

	public static Map<String,String> getCasCookiesBeforeRedirect()
	{
		Map casCookiesBeforeRedirect = new HashMap();
		
	    String customContentTypeIconsString = CmsPropertyHandler.getServerNodeDataProperty(null, "casCookiesBeforeRedirect", true, null);
	    if(customContentTypeIconsString != null && !customContentTypeIconsString.equals(""))
		{
	    	try
			{
	    		Properties properties = new Properties();
				properties.load(new ByteArrayInputStream(customContentTypeIconsString.getBytes("UTF-8")));
				casCookiesBeforeRedirect.putAll(properties);
			}	
			catch(Exception e)
			{
			    logger.error("Error loading properties from string. Reason:" + e.getMessage());
			}
		}
	    
	    return casCookiesBeforeRedirect;
	}

	public static String getAllowedFolderContentTypeNames()
	{
		String customContentTypeIconsString = getServerNodeProperty("allowedFolderContentTypeNames", false, "Folder");
	    
	    return customContentTypeIconsString;
	}

	public static Map getCacheSettings()
	{
		return getCacheSettings(false);
	}
	
	public static Map getCacheSettings(boolean skipCaches)
	{
		if(cacheSettings == null || skipCaches)
		{
			Map localCacheSettings = new HashMap();
			
		    String cacheSettingsString = CmsPropertyHandler.getServerNodeDataProperty(null, "cacheSettings", true, null, skipCaches);
		    if(cacheSettingsString != null && !cacheSettingsString.equals(""))
			{
		    	try
				{
		    		Properties properties = new Properties();
					properties.load(new ByteArrayInputStream(cacheSettingsString.getBytes("UTF-8")));
					localCacheSettings = properties;
					CacheController.pattern = null;
				}	
				catch(Exception e)
				{
				    logger.error("Error loading properties from string. Reason:" + e.getMessage(), e);
				}
			}
		    cacheSettings = localCacheSettings;
		}

		return cacheSettings; 
	}

	private static Properties loadPropertiesFromString(String propertiesString, Properties currentProperties)
	{
		if (propertiesString != null && !propertiesString.equals(""))
		{
			try
			{
				currentProperties = new Properties(currentProperties);
				currentProperties.load(new ByteArrayInputStream(propertiesString.getBytes("UTF-8")));
				return currentProperties;
			}
			catch(Exception ex)
			{
				logger.error("Error loading general settings from string. Reason:" + ex.getMessage());
				logger.warn("Error loading general settings from string.", ex);
			}
		}
		return currentProperties;
	}

	public static Properties getGeneralSettings(boolean skipCaches)
	{
		if (generalSettings == null || skipCaches)
		{
			String generalSettingsString = CmsPropertyHandler.getServerNodeDataProperty(null, "generalSettings", true, null, skipCaches);
			CmsPropertyHandler.generalSettings = loadPropertiesFromString(generalSettingsString, null);
			if (CmsPropertyHandler.getOperatingMode().equals("0"))
			{
				logger.debug("Loading extra general settings for working instance.");
				String workingGeneralSettingsString = CmsPropertyHandler.getServerNodeDataProperty(null, "workingGeneralSettings", true, null, skipCaches);
				CmsPropertyHandler.generalSettings = loadPropertiesFromString(workingGeneralSettingsString, CmsPropertyHandler.generalSettings);
			}
		}
		return generalSettings;
	}

	public static List<String> getExtraPublicationPersistentCacheNames() 
	{
		List<String> cacheNames = new ArrayList<String>();
		
	    String extraPublicationPersistentCacheNamesString = CmsPropertyHandler.getServerNodeDataProperty(null, "extraPublicationPersistentCacheNames", true, null, true);
	    if(extraPublicationPersistentCacheNamesString != null && !extraPublicationPersistentCacheNamesString.equals(""))
		{
	    	String[] names = extraPublicationPersistentCacheNamesString.split("(\n|\r|\r\n)");
	    	for(int i=0; i<names.length; i++)
	    	{
	    		String name = names[i].trim();
	    		if(!name.equals(""))
	    			cacheNames.add(name);
	    	}
		}
	    
	    return cacheNames;
	}

	private static PropertySet getPropertySet()
	{
		if(propertySet == null)
			restorePropertySet();
		
		return propertySet;
	}

	public static String getPropertySetValue(String key)
	{
		return getPropertySetValue(key, false);
	}

	public static String getPropertySetValue(String key, boolean skipCaches)
	{
	    String value = null;
	    
        String cacheKey = "" + key;
        String cacheName = "propertySetCache";
		//logger.info("cacheKey:" + cacheKey);
        if(!skipCaches)
        	value = (String)CacheController.getCachedObject(cacheName, cacheKey);
		
        if(value != null)
		{
        	if(logger.isInfoEnabled())
        		logger.info("Returning property " + cacheKey + " value " + value);
			return value;
		}
	    
		value = getPropertySet().getString(key);
		logger.info("propertySetCache did not have value... refetched:" + value);
	    
		if(!skipCaches)
			CacheController.cacheObject(cacheName, cacheKey, value);
	    
	    return value;
	}

	public static String getAnonymousPassword()
	{
		String password = "anonymous";
		//String specifiedPassword = getProperty("security.anonymous.password");
		String specifiedPassword = getServerNodeProperty("deliver", "security.anonymous.password", true, "anonymous");
		if(specifiedPassword != null && !specifiedPassword.equalsIgnoreCase("") && specifiedPassword.indexOf("security.anonymous.password") == -1)
			password = specifiedPassword;
		
		return password;
	}

	public static String getAnonymousUser()
	{
		String userName = "anonymous";
		String specifiedUserName = getServerNodeProperty("deliver", "security.anonymous.username", true, "anonymous");
		if(specifiedUserName != null && !specifiedUserName.equalsIgnoreCase("") && specifiedUserName.indexOf("security.anonymous.username") == -1)
			userName = specifiedUserName;
		
		return userName;
	}

	public static Properties getCharacterReplacingMapping()
	{
		Properties properties = new Properties();

		String characterReplacingMappingString = CmsPropertyHandler.getServerNodeDataProperty(null, "niceURICharacterReplacingMapping", true, null);
		logger.info("characterReplacingMappingString:" + characterReplacingMappingString);
	    if(characterReplacingMappingString != null && !characterReplacingMappingString.equals(""))
		{
	    	try
			{
				properties.load(new ByteArrayInputStream(characterReplacingMappingString.getBytes("ISO-8859-1")));
			}	
			catch(Exception e)
			{
			    logger.error("Error loading properties from string. Reason:" + e.getMessage());
				e.printStackTrace();
			}
		}
	    if(properties.size() == 0)
	    {
	    	properties.put("\u00E5", "a");
	    	properties.put("\u00E4", "a");
	    	properties.put("\u00F6", "o");
	    	properties.put("\u00C5", "A");
	    	properties.put("\u00C4", "A");
	    	properties.put("\u00D6", "O");
	    }
	    
	    return properties;
	}

	public static boolean getNiceURIUseLowerCase()
	{
		String niceURIUseLowerCase = getServerNodeProperty("niceURIUseLowerCase", true, "false");
		
		return Boolean.parseBoolean(niceURIUseLowerCase);
	}

	public static String getNiceURIDefaultReplacementCharacter()
	{
		return getServerNodeProperty("niceURIDefaultReplacementCharacter", true, "_");
	}

	public static String getNiceURIDefaultReplacementCharacterForContent()
	{
		return getServerNodeProperty("niceURIDefaultReplacementCharacterForContent", true, getNiceURIDefaultReplacementCharacter());
	}

	public static String getUseAccessBasedProtocolRedirects()
	{
		return getUseAccessBasedProtocolRedirects(false);
	}

	public static String getUseAccessBasedProtocolRedirects(boolean skipHardCache)
	{
		if(useAccessBasedProtocolRedirects == null || skipHardCache)
		{
			useAccessBasedProtocolRedirects = getServerNodeProperty("useAccessBasedProtocolRedirects", true, "false");
		}
		
		return useAccessBasedProtocolRedirects;
	}
	
	public static String getDeriveProtocolWhenUsingProtocolRedirects()
	{
		return getServerNodeProperty("deriveProtocolWhenUsingProtocolRedirects", true, "false");
	}

	public static String getUnprotectedProtocolName()
	{
		return getServerNodeProperty("unprotectedProtocolName", true, "http");
	}

	public static String getProtectedProtocolName()
	{
		return getServerNodeProperty("protectedProtocolName", true, "https");
	}

	public static String getUnprotectedProtocolPort()
	{
		return getServerNodeProperty("unprotectedProtocolPort", true, "8080");
	}

	public static String getProtectedProtocolPort()
	{
		return getServerNodeProperty("protectedProtocolPort", true, "8443");
	}

	public static String getAccessBasedProtocolRedirectHTTPCode()
	{
		return getServerNodeProperty("accessBasedProtocolRedirectHTTPCode", true, "301");
	}

	public static int getRedirectStatusCode()
	{
		try
		{
			return Integer.parseInt(getServerNodeProperty("redirectStatusCode", true, "301"));
		}
		catch (NumberFormatException nfe)
		{
			logger.warn("Failed to parse redirectStatusCode. Will return default value. Message: " + nfe.getMessage());
			return 301;
		}
	}

	/**
	 * If the user has set a error-url to http://www.google.se we could either sendRedirect or do a http-backend include. The incude 
	 * will be able to return the error page html AND a 404 status code. The old method will transfer the user and give robots etc the impression that 
	 * the page just moved.
	 * @return
	 */
	public static String getResponseMethodOnFullErrorURL()
	{
		return getServerNodeProperty("responseMethodOnFullErrorURL", true, "include");
	}

	/**
	 * If a repository has no access rights defined - should it be available to users or not by default?
	 * @return
	 */
	public static boolean getShowRepositoriesByDefaultIfNoAccessRightsAreDefined()
	{
		String showRepositoriesByDefaultIfNoAccessRightsAreDefined = getServerNodeProperty("showRepositoriesByDefaultIfNoAccessRightsAreDefined", true, "true");
		
		return Boolean.parseBoolean(showRepositoriesByDefaultIfNoAccessRightsAreDefined);
	}

	/**
	 * Enable disk based deployment or not?
	 * @return
	 */
	public static boolean getEnableDiskBasedDeployment()
	{
		String enableDiskBasedDeployment = getServerNodeProperty("enableDiskBasedDeployment", true, "false");
	
		return Boolean.parseBoolean(enableDiskBasedDeployment);
	}
	
	/**
	 * Enable disk based deployment or not?
	 * @return
	 */
	public static boolean getEnableDiskBasedDeployment(boolean skipCaches)
	{
		String enableDiskBasedDeployment = getServerNodeProperty("enableDiskBasedDeployment", true, "false", skipCaches);
	
		return Boolean.parseBoolean(enableDiskBasedDeployment);
	}


	/**
	 * The folder to sync for changes. See doc for folder structure and content.
	 * @return
	 */
	public static String getDiskBasedDeploymentBasePath()
	{
		String diskBasedDeploymentBasePath = getServerNodeProperty("diskBasedDeploymentBasePath", true, "");
		if(diskBasedDeploymentBasePath != null && diskBasedDeploymentBasePath.contains("\\"))
			diskBasedDeploymentBasePath = diskBasedDeploymentBasePath.replace("\\", "/");
		return diskBasedDeploymentBasePath;
	}

	
	public static String getDefaultRepositoryAccessRoles()
	{
		return getServerNodeProperty("defaultRepositoryAccessRoles", true, null);
	}

	public static String getLoginUrl()
	{
		return getServerNodeProperty("loginUrl", true, "");
	}

	public static String getLogoutUrl()
	{
		return getServerNodeProperty("logoutUrl", true, "");
	}

	public static String getInvalidLoginUrl()
	{
		return getServerNodeProperty("invalidLoginUrl", true, "");
	}

	public static String getSuccessLoginBaseUrl()
	{
		return getServerNodeProperty("successLoginBaseUrl", true, "");
	}

	public static String getAuthenticatorClass()
	{
		return getServerNodeProperty("authenticatorClass", true, "");
	}

	public static String getAuthorizerClass()
	{
		return getServerNodeProperty("authorizerClass", true, "");
	}

	public static String getAuthConstraint()
	{
		return getServerNodeProperty("authConstraint", true, "");
	}

	public static String getLightAuthConstraint()
	{
		return getServerNodeProperty("lightAuthConstraint", true, "lightCmsUser");
	}

	public static String getLightUserAllowedURIRegexp()
	{
		return getServerNodeProperty("lightUserAllowedURIRegexp", true, ".*?(Content|SiteNode|DigitalAsset|ViewCommonAjaxServices).*?");
	}

	public static String getExtraSecurityParameters()
	{
		return "";
	}

	public static String getCasValidateUrl()
	{
		return getServerNodeProperty("casValidateUrl", true, "");
	}

	public static String getCasProxyValidateUrl()
	{
		return getServerNodeProperty("casProxyValidateUrl", true, "");
	}

	public static String getCasServiceUrl()
	{
		return getServerNodeProperty("casServiceUrl", true, "");
	}

	public static String getCasLogoutUrl()
	{
		return getServerNodeProperty("casLogoutUrl", true, "");
	}

	public static String getDeliverLoginUrl()
	{
		return getServerNodeProperty("deliver", "loginUrl", true, "");
	}

	public static String getDeliverLogoutUrl()
	{
		return getServerNodeProperty("deliver", "logoutUrl", true, "");
	}

	public static String getDeliverInvalidLoginUrl()
	{
		return getServerNodeProperty("deliver", "invalidLoginUrl", true, "");
	}

	public static String getDeliverSuccessLoginBaseUrl()
	{
		return getServerNodeProperty("deliver", "successLoginBaseUrl", true, "");
	}

	public static String getDeliverAuthenticatorClass()
	{
		return getServerNodeProperty("deliver", "authenticatorClass", true, "");
	}

	public static String getDeliverAuthorizerClass()
	{
		return getServerNodeProperty("deliver", "authorizerClass", true, "");
	}

	public static String getDeliverAuthConstraint()
	{
		return getServerNodeProperty("deliver", "authConstraint", true, "");
	}

	public static String getDeliverExtraSecurityParameters()
	{
		return "";
	}

	public static String getDeliverCasValidateUrl()
	{
		return getServerNodeProperty("deliver", "casValidateUrl", true, "");
	}

	public static String getDeliverCasProxyValidateUrl()
	{
		return getServerNodeProperty("deliver", "casProxyValidateUrl", true, "");
	}

	public static String getDeliverCasServiceUrl()
	{
		return getServerNodeProperty("deliver", "casServiceUrl", true, "");
	}

	public static String getDeliverCasLogoutUrl()
	{
		return getServerNodeProperty("deliver", "casLogoutUrl", true, "");
	}

	public static String getIpAddressesToFallbackToBasicAuth()
	{
		return getServerNodeProperty("ipAddressesToFallbackToBasicAuth", true, "");
	}

	public static String getUserAgentsSkippingSSOCheck()
	{
		String userAgentsSkippingSSOCheckString = CmsPropertyHandler.getServerNodeDataProperty("deliver", "userAgentsSkippingSSOCheck", true, null);
	    
	    return userAgentsSkippingSSOCheckString;
	}

	public static String getIpNumbersSkippingSSOCheck()
	{
		String ipNumbersSkippingSSOCheckString = CmsPropertyHandler.getServerNodeDataProperty("deliver", "ipNumbersSkippingSSOCheck", true, null);
		
	    return ipNumbersSkippingSSOCheckString;
	}

	public static boolean getDisableDecoratedFinalRendering()
	{
		String disableDecoratedFinalRendering = getServerNodeProperty("disableDecoratedFinalRendering", true, "false");
		
		return Boolean.parseBoolean(disableDecoratedFinalRendering);
	}
	
	public static boolean getAllowInternalCallsBasedOnIP() 
	{
		String allowInternalCallsBasedOnIP = getServerNodeProperty("allowInternalCallsBasedOnIP", true, "true");
		
		return Boolean.parseBoolean(allowInternalCallsBasedOnIP);
	}

	public static boolean getUseGlobalRepositoryChange() 
	{
		String useGlobalRepositoryChange = getServerNodeProperty("useGlobalRepositoryChange", true, "false");
		
		return Boolean.parseBoolean(useGlobalRepositoryChange);
	}
	
	private static Boolean useSQLServerDialect = null;
	public static boolean getUseSQLServerDialect()
	{
        if(useSQLServerDialect == null)
        {
            String databaseEngine = CmsPropertyHandler.getDatabaseEngine();
            if(databaseEngine == null || (!databaseEngine.equalsIgnoreCase("mssql") && !databaseEngine.equalsIgnoreCase("sql-server") && !databaseEngine.equalsIgnoreCase("SQL Server")))
            {
            	useSQLServerDialect = new Boolean(false);
            }
            else
            {
            	useSQLServerDialect = new Boolean(true);
            }
        }
        
        return useSQLServerDialect.booleanValue();
	}

	public static String getAssetFileNameForm() 
	{
		return getServerNodeProperty("assetFileNameForm", true, "contentId_languageId_assetKey");
	}

	public static String getSQLUpgradePath() 
	{
		return "" + getContextRootPath() + "up2date" + File.separator + "sql";
	}

	private static Boolean configurationFinished = null;
	public static boolean getIsConfigurationFinished()
	{
		try 
		{
			if(configurationFinished == null || configurationFinished == false)
				configurationFinished = InstallationController.getController().validateApplicationFile();
		} 
		catch (Exception e) 
		{
			logger.error("Could not check if infoglue was configured: " + e.getMessage(), e);
		}
		
		return configurationFinished;
	}

	private static Boolean isValidSetup = false;
	public static void setIsValidSetup(Boolean isValidSetup) 
	{
		CmsPropertyHandler.isValidSetup = isValidSetup;
	}
	public static Boolean getIsValidSetup() 
	{
		return CmsPropertyHandler.isValidSetup;
	}
  
  @SuppressWarnings("unchecked")
	public static Map<String, String> getStandardResponseHeaders()
	{
		String standardResponseHeadersString = getServerNodeProperty("standardResponseHeaders", true, null);
		if (standardResponseHeadersString == null)
		{
			return new HashMap<String, String>();
		}

		try
		{
			return httpHelper.toMap(standardResponseHeadersString, "utf-8");
		}
		catch (Exception ex)
		{
			logger.warn("Failed to parse standard response headers. String: " + standardResponseHeadersString + ". Message: " + ex.getMessage());
			return new HashMap<String, String>();
		}
  }

  public static boolean getIndexDigitalAssetContent()
	{
		String value = getServerNodeProperty("indexDigitalAssetContent", true, "false");

		return Boolean.parseBoolean(value);
  }

	public static String getContactPersonEmailMetaInfoAttribute()
	{
		return getServerNodeProperty("contactPersonEmailMetaInfoAttribute", true, "PageResponsibleEmail");
	}

	public static boolean getNotifyResponsibleOnReferenceChange()
	{
		String notifyResponsibleOnReferenceChange = getServerNodeProperty("notifyResponsibleOnReferenceChange", true, "false");

		return Boolean.parseBoolean(notifyResponsibleOnReferenceChange);
	}

	public static String getRegistryContactMailLanguage()
	{
		return getServerNodeProperty("registryContactMailLanguage", true, "en");
	}

	public static boolean getOnlyShowReferenceIfLatestVersion()
	{
		String onlyShowReferenceIfLatestVersion = getServerNodeProperty("onlyShowReferenceIfLatestVersion", true, "false");

		return Boolean.parseBoolean(onlyShowReferenceIfLatestVersion);
	}

	public static boolean getRedirectUsingSystemRedirect()
	{
		String redirectUsingSystemRedirect = getServerNodeProperty("redirectUsingSystemRedirect", true, "false");

		return Boolean.parseBoolean(redirectUsingSystemRedirect);
	}

	public static boolean getOrderRedirectsByLength()
	{
		String orderRedirectsByLength = getServerNodeProperty("orderRedirectsByLength", true, "false");

		return Boolean.parseBoolean(orderRedirectsByLength);
	}

	/**
	 * Dev note: This method is not used at all places where it should be used so don't depend on that. However
	 * it is good if new features utilize this property so that in the future we can depend on this attribute.
	 * (Comment written on 2014-01-24)
	 */
	
	public static String getMetaDataContentTypeDefinitionName()
	{
		return getServerNodeProperty("metaDataContentTypeDefinitionName", true, "Meta info");
	}

	public static String getExpectFormPostToBeUnicodeAllready() 
	{
		return getServerNodeProperty("expectFormPostToBeUnicodeAllready", true, "true");
	}
	
	public static boolean getForceHTTPProtocol() 
	{
		String forceHTTPProtocol = getServerNodeProperty("forceHTTPProtocol", true, "false");
	
		return Boolean.parseBoolean(forceHTTPProtocol);
	}
	
	public static boolean getViewInheritedAssetsInContentDialog() 
	{
		String viewInheritedAssetsInContentDialog = getServerNodeProperty("viewInheritedAssetsInContentDialog", true, "true");
		return Boolean.parseBoolean(viewInheritedAssetsInContentDialog);
	}
	
	/**
	 * Setting which determines if you wanna skip cleaning up references in content
	 * @return boolean
	 */
	
	public static boolean getCleanReferencesAfterDelete() 
	{
		String cleanReferencesAfterDelete = getServerNodeProperty("cleanReferencesAfterDelete", true, "true");
	
		return Boolean.parseBoolean(cleanReferencesAfterDelete);
	}
	
	public static float getWebappVersion()
	{
		String webappVersion = getServerNodeProperty("webappVersion", true, "2.3");
		try
		{
			return Float.parseFloat(webappVersion);
		}
		catch(Exception e) 
		{
			logger.error("Problem getting webapp version: " + e.getMessage());
		}
		
		return 1F;
	}

	/**
	 * Indicates that the structure tool should be reloaded when activated
	 */
	public static boolean getReloadStructureOnActivation()
	{
		return Boolean.parseBoolean(getServerNodeProperty("reloadStructureOnActivation", false, "false"));
	}

	public static boolean getUseWriteForAccessControlInWorking() 
	{
		return Boolean.parseBoolean(getServerNodeProperty("useWriteForAccessControlInWorking", false, "false"));
	}

	public static boolean getDoubleCheckComponentEditorRights() {
		return Boolean.parseBoolean(getServerNodeProperty("doubleCheckComponentEditorRights", false, "false"));
	}

	public static String getOptionalContentMode()
	{
		return getServerNodeProperty("optionalContentMode", false, "content");
	}

	public static String getOptionalContentHashSlotName()
	{
		/*
		 * The default value is used by the user who implemented the feature. Since there is not
		 * appropriate default value their desired value is used as default.
		 */
		return getServerNodeProperty("optionalContentHashSlotName", false, "komponentplats 2/slot 2");
	}

	public static String getOptionalContentHashPropertyName()
	{
		/*
		 * The default value is used by the user who implemented the feature. Since there is not
		 * appropriate default value their desired value is used as default.
		 */
		return getServerNodeProperty("optionalContentHashPropertyName", false, "Article");
	}

	public static boolean shouldTomcatGzipResources() {
		String value = getServerNodeProperty("gzipResourcesWithTomcat", true, "true");
		return Boolean.parseBoolean(value);
	}

	public static String getExternalImageOptimizer()
	{
		return getServerNodeProperty("digitalAssetOptimizer", true, null);
	}

}