MelatiConfig.java
/*
* $Source$
* $Revision$
*
* Copyright (C) 2000 Tim Joyce
*
* Part of Melati (http://melati.org), a framework for the rapid
* development of clean, maintainable web applications.
*
* Melati is free software; Permission is granted to copy, distribute
* and/or modify this software under the terms either:
*
* a) the GNU General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version,
*
* or
*
* b) any version of the Melati Software License, as published
* at http://melati.org
*
* You should have received a copy of the GNU General Public License and
* the Melati Software License along with this program;
* if not, write to the Free Software Foundation, Inc.,
* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
* GNU General Public License and visit http://melati.org to obtain the
* Melati Software License.
*
* Feel free to contact the Developers of Melati (http://melati.org),
* if you would like to work out a different arrangement than the options
* outlined here. It is our intention to allow Melati to be used by as
* wide an audience as possible.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* Contact details for copyright holder:
*
* Tim Joyce <timj At paneris.org>
* http://paneris.org/
* 68 Sandbanks Rd, Poole, Dorset. BH14 8BY. UK
*/
package org.melati;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;
import java.util.Properties;
import java.util.Vector;
import org.melati.login.AccessHandler;
import org.melati.poem.PoemLocale;
import org.melati.poem.util.EnumUtils;
import org.melati.servlet.FormDataAdaptorFactory;
import org.melati.template.ClassNameTempletLoader;
import org.melati.template.ServletTemplateEngine;
import org.melati.template.SimpleDateAdaptor;
import org.melati.template.TemplateEngine;
import org.melati.template.TempletLoader;
import org.melati.template.YMDDateAdaptor;
import org.melati.template.YMDHMSTimestampAdaptor;
import org.melati.util.ConfigException;
import org.melati.util.HttpHeader;
import org.melati.util.PropertiesUtils;
/**
* A MelatiConfig loads and provides access to the configuration parameters for
* Melati. These are held in <TT>org.melati.MelatiConfig.properties</TT>.
*/
public class MelatiConfig {
private Properties configuration = null;
private String propertiesPrefix = "org.melati.MelatiConfig";
private AccessHandler accessHandler = null;
private FormDataAdaptorFactory fdaFactory = null;
private TempletLoader templetLoader = null;
private TemplateEngine templateEngine = null;
private static PoemLocale poemLocale = null;
private Vector<String> preferredCharsets = null;
private String javascriptLibraryURL = null;
private String staticURL = null;
private String templatePath = null;
private static String loginPageServletClassName = "org.melati.login.Login";
private static String logoutPageServletClassName = "org.melati.login.Logout";
private static String realPath = null;
/**
* Allows creation of a <code>MelatiConfig</code> with default config
* params.
*/
public MelatiConfig() {
propertiesPrefix = getClass().getCanonicalName();
try {
configuration = PropertiesUtils.fromResource(getClass(), propertiesPrefix + ".properties");
}
catch (FileNotFoundException e) {
configuration = new Properties();
// TimJ: i think that if we don't have a properties file, it is pretty fatal
// TimP: Naah
}
catch (IOException e) {
throw new ConfigException("The file " + propertiesPrefix + ".properties" +
" could not be read.", e);
}
init(propertiesPrefix);
}
/**
* Allows creation of a <code>MelatiConfig</code> with a specified
* properties file.
*
* @param propertiesFilename
* the name of a properties file
*/
public MelatiConfig(String propertiesFilename) {
configuration = getProperties(propertiesFilename);
init(propertiesFilename);
}
/**
* Constructor from a given Properties object.
* @param properties the properties object to look in
*/
public MelatiConfig(Properties properties) {
configuration = properties;
init(propertiesPrefix);
}
public static Properties getProperties() {
return getProperties(MelatiConfig.class.getCanonicalName());
}
public static Properties getProperties(String propertiesName) {
try {
return PropertiesUtils.fromResource(MelatiConfig.class, propertiesName + ".properties");
}
catch (FileNotFoundException e) {
throw new ConfigException("The file " + propertiesName + "properties" +
" could not be found." +
" Is it in your CLASSPATH?", e);
}
catch (IOException e) {
throw new ConfigException("The file " + propertiesName + ".properties" +
" could not be read.", e);
}
}
@SuppressWarnings("unchecked")
void init(String propertiesNameIn) {
this.propertiesPrefix = propertiesNameIn;
String pref = propertiesPrefix + ".";
String accessHandlerProp = pref + "accessHandler";
String fdaFactoryProp = pref + "formDataAdaptorFactory";
String templetLoaderProp = pref + "templetLoader";
String templateEngineProp = pref + "templateEngine";
String templatePathProp = pref + "templatePath";
String javascriptLibraryURLProp = pref + "javascriptLibraryURL";
String staticURLProp = pref + "staticURL";
String melatiLocaleProp = pref + "locale";
String preferredCharsetsProp = pref + "preferredCharsets";
String loginPageServletClassNameProp = pref + "loginPageServletClassName";
String logoutPageServletClassNameProp = pref + "logoutPageServletClassName";
try {
setAccessHandler((AccessHandler)PropertiesUtils.
instanceOfNamedClass(
configuration,
accessHandlerProp,
"org.melati.login.AccessHandler",
"org.melati.login.OpenAccessHandler"));
setFdaFactory((FormDataAdaptorFactory)PropertiesUtils.
instanceOfNamedClass(
configuration,
fdaFactoryProp,
"org.melati.servlet.FormDataAdaptorFactory",
"org.melati.servlet.MemoryFormDataAdaptorFactory"));
String templetLoaderClassName = (String)configuration.get(templetLoaderProp);
if(templetLoaderClassName == null ||
templetLoaderClassName.equals("org.melati.template.ClassNameTempletLoader")) {
setTempletLoader(ClassNameTempletLoader.getInstance());
} else
setTempletLoader((TempletLoader)PropertiesUtils.
instanceOfNamedClass(
configuration,
templetLoaderProp,
"org.melati.template.TempletLoader",
"org.melati.template.ClassNameTempletLoader"));
setTemplateEngine((TemplateEngine)PropertiesUtils.
instanceOfNamedClass(
configuration,
templateEngineProp,
"org.melati.template.TemplateEngine",
"org.melati.template.NoTemplateEngine"));
String languageTag = PropertiesUtils.getOrDefault(configuration,
melatiLocaleProp,
"en-gb");
setPoemiLocale(PoemLocale.fromLanguageTag(languageTag));
if (poemLocale == null)
throw new ConfigException(languageTag +
" is not a valid language tag for " +
melatiLocaleProp);
// This is a fancy way of splitting, trimming and checking for
// errors such as spaces within fields.
// It reflects the fact that the config file format
// is like a quoteless Http header field.
setPreferredCharsets(
EnumUtils.vectorOf(
new HttpHeader(PropertiesUtils.getOrDefault(
configuration,
preferredCharsetsProp,
"ISO-8859-1, UTF-8, UTF-16")).wordIterator()));
setJavascriptLibraryURL(PropertiesUtils.getOrDefault(
configuration,
javascriptLibraryURLProp,
"/melati-static/admin/"));
setStaticURL(PropertiesUtils.getOrDefault(
configuration,
staticURLProp,
"/melati-static/"
));
setTemplatePath(PropertiesUtils.getOrDefault(configuration,
templatePathProp, "."));
setLoginPageServletClassName(PropertiesUtils.getOrDefault(configuration,
loginPageServletClassNameProp, loginPageServletClassName));
setLogoutPageServletClassName(PropertiesUtils.getOrDefault(configuration,
logoutPageServletClassNameProp, logoutPageServletClassName));
}
catch (Exception e) {
throw new ConfigException("Melati could not be configured", e);
}
}
/**
* @return {@link ServletTemplateEngine} in use.
*/
public ServletTemplateEngine getServletTemplateEngine() {
return (ServletTemplateEngine)templateEngine;
}
/**
* @return {@link TemplateEngine} in use.
*/
public TemplateEngine getTemplateEngine() {
return templateEngine;
}
/**
* Set the {@link TemplateEngine} to use.
*
* @param templateEngine
* a {@link TemplateEngine}
*/
public void setTemplateEngine(TemplateEngine templateEngine) {
this.templateEngine = templateEngine;
}
/**
* @return the configured {@link AccessHandler}
*/
public AccessHandler getAccessHandler() {
return accessHandler;
}
/**
* Set the <code>AccessHandler</code> for use by this Melati.
*
* @param accessHandler
* a {@link AccessHandler}
*/
public void setAccessHandler(AccessHandler accessHandler) {
this.accessHandler = accessHandler;
}
/**
* @return the configured {@link TempletLoader}
*/
public TempletLoader getTempletLoader() {
return templetLoader;
}
/**
* Set the {@link TempletLoader} for use by this Melati.
*
* @param templetLoader
* a {@link TempletLoader}
*/
public void setTempletLoader(TempletLoader templetLoader) {
this.templetLoader = templetLoader;
}
/**
* @return the configured {@link FormDataAdaptorFactory}
*/
public FormDataAdaptorFactory getFormDataAdaptorFactory() {
return fdaFactory;
}
/**
* Set the {@link FormDataAdaptorFactory} for use by this Melati.
*
* @param fdaf
* a {@link FormDataAdaptorFactory}
*/
public void setFormDataAdaptorFactory(FormDataAdaptorFactory fdaf) {
fdaFactory = fdaf;
}
/**
* @return the location of javascript for this site.
*/
public String getJavascriptLibraryURL() {
return javascriptLibraryURL;
}
/**
* Set the <code>JavascriptLibraryURL</code> for use by this Melati.
*
* @param url
* a URL to the directory containing the JavaScript for this site
*/
public void setJavascriptLibraryURL(String url) {
this.javascriptLibraryURL = url;
}
/**
* Normally set to <code>melati-static</code>.
*
* @return the location of static content for this site.
*/
public String getStaticURL() {
return staticURL;
}
/**
* Set the <code>StaticURL</code> for use by this Melati.
*
* @param url
* a URL to the directory containing the static content
*/
public void setStaticURL(String url) {
this.staticURL = url;
}
/**
* @return the location of templates.
*/
public String getTemplatePath() {
return templatePath;
}
/**
* @param templatePath
* The templatePath to set.
*/
public void setTemplatePath(String templatePath) {
this.templatePath = templatePath;
}
/**
* @return the class name of the logout servlet
*/
public static String getLogoutPageServletClassName() {
return logoutPageServletClassName;
}
/**
* @param logoutPageServletClassName
* The logoutPageServletClassName to set.
*/
public static void setLogoutPageServletClassName(
String logoutPageServletClassName) {
MelatiConfig.logoutPageServletClassName = logoutPageServletClassName;
}
/**
* @return the class name of the login servlet
*/
public static String getLoginPageServletClassName() {
return loginPageServletClassName;
}
/**
* @param loginPageServletClassName
* The loginPageServletClassName to set.
*/
public static void setLoginPageServletClassName(
String loginPageServletClassName) {
MelatiConfig.loginPageServletClassName = loginPageServletClassName;
}
/**
* @return The configured locale, defaults to British English melati locale.
*/
public static PoemLocale getPoemLocale() {
if (poemLocale == null)
poemLocale = PoemLocale.HERE;
return poemLocale;
}
/**
* @param poemLocale
* The PoemLocale to set.
*/
public void setPoemiLocale(PoemLocale poemLocale) {
MelatiConfig.poemLocale = poemLocale;
}
/**
* Return the set encodings that the server prefers and supports.
*
* @return List of encoding names or aliases.
*/
public List<String> getPreferredCharsets() {
return preferredCharsets;
}
/**
* @param preferredCharsets
* The preferredCharsets to set.
*/
public void setPreferredCharsets(Vector<String> preferredCharsets) {
this.preferredCharsets = preferredCharsets;
}
/**
* @return Returns the fdaFactory.
*/
public FormDataAdaptorFactory getFdaFactory() {
return fdaFactory;
}
/**
* @param fdaFactory
* The fdaFactory to set.
*/
public void setFdaFactory(FormDataAdaptorFactory fdaFactory) {
this.fdaFactory = fdaFactory;
}
//
// Non configurable but here to make them available in a template context.
//
/**
* Called from within templets using
* <code>
* #set $yearField = $melati.Config.YMDDateAdaptor.yearField($field)
* </code>
* idiom.
* Perhaps this should be elsewhere.
* @return the adaptor for rendering dates as drop-downs.
*/
public static YMDDateAdaptor getYMDDateAdaptor() {
return YMDDateAdaptor.it;
}
/**
* Called from within templets using
* <code>
* #set $secondField = $melati.Config.YMDHMSTimestampAdaptor.secondField($field)
* </code>
* idiom.
* Perhaps this should be elsewhere.
* @return the adaptor for rendering timestamps as drop-downs.
*/
public static YMDHMSTimestampAdaptor getYMDHMSTimestampAdaptor() {
return YMDHMSTimestampAdaptor.getIt();
}
/**
* Called from within templets.
* Perhaps this should be elsewhere.
* @return the adaptor for rendering dates as normal.
*/
public static SimpleDateAdaptor getSimpleDateAdaptor() {
return SimpleDateAdaptor.it;
}
/**
* @param realPathP the path to set
*/
public void setRealPath(String realPathP) {
realPath = realPathP;
}
/**
* @return the real path, if set null otherwise
*/
public String getRealPath() {
return realPath;
}
}