ElephantContext.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2013 Lluis Turró Cutiller <http://www.turro.org/>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
package org.turro.elephant.context;
 
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Currency;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.turro.string.Strings;
import org.apache.commons.codec.binary.Base64;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.XMLOutputter;
import org.turro.annotation.ElephantConstructor;
import org.turro.collections.CollectionUtil;
import org.turro.config.Configurator;
import org.turro.elephant.impl.security.Cipher;
import org.turro.file.Folder;
import org.turro.json.Jsons;
import org.turro.path.Path;
import org.turro.reflection.Instances;
 
@WebListener
public class ElephantContext implements ServletContextListener {
  
  private static ServletContext _context;
  private static ArrayList<String> _metas;
 
  /* ServletContextListener */
  
  // Required to load listener
  public ElephantContext() {
  }
 
  @Override
    public void contextDestroyed(ServletContextEvent event) {
        _context = null;
    }
 
    @Override
    public void contextInitialized(ServletContextEvent event) {
        _context = event.getServletContext();
    loadSiteConfiguration();
    Configurator.init(ElephantContext.getRealPath("/WEB-INF/elephant/conf/configurator/context.json"));
    }
  
    /* Site */
  
  public static Jsons siteInfo() {
    return Jsons.object()
            .add("name", ElephantContext.getSiteName())
            .add("description", ElephantContext.getSiteDescription())
            .add("icon", ElephantContext.getServerBase("http") + ElephantContext.getSiteIcon())
            .add("url", ElephantContext.getServerUrl("http"))
            .add("locales", ElephantContext.getSiteLocales());
  }
  
  /* Helpers */
  
  public static ServletContext getCurrent() {
    return _context;
  }
  
  public static IConstructor createConstructor() {
    return ElephantContext.getConstructor(null, null);
  }
  
  public static List<String> getMetas() {
    return _metas;
  }
  
  public static String removeWebContext(String path) {
    String remove = getRootWebPath();
    if(!Strings.isBlank(remove) && path.startsWith(remove)) {
      return path.substring(remove.length());
    }
    return path;
  }
 
  public static String getRealPath(String path) {
    String real = getCurrent().getRealPath(path);
    if(real != null) {
      real = real.replaceAll("\\\\", "/");
      if(real.endsWith("/"))
        real = real.substring(0, real.length() - 1);
    }
    return real;
  }
 
  public static String getRelativePath(String path) {
    String remove = getRealPath("/");
    if(path.startsWith(remove)) {
      return path.substring(remove.length());
    }
    return null;
  }
  
  public static String getContextVariable(IConstructor constructor) {
    return constructor.getCurrentContext().getPath();
  }
  
  public static String getRootWebPath() {
    return _context.getContextPath();
  }
  
  public static String getRootResourcePath() {
    return getRootWebPath();
  }
  
  public static Object getAttribute(String key) {
    return _context.getAttribute(key);
  }
 
  public static void setAttribute(String key, Object value) {
    _context.setAttribute(key, value);
  }
 
  public static void removeAttribute(String key) {
    _context.removeAttribute(key);
  }
 
  public static String getSiteName() {
    return (String) getAttribute("site_name");
  }
  
  public static String getSiteForcedDomain() {
    return (String) getAttribute("site_forced-domain");
  }
  
  public static String getSiteDescription() {
    return (String) getAttribute("site_description");
  }
  
  public static String getSiteKeywords() {
    return (String) getAttribute("site_keywords");
  }
  
  public static String getSiteFonts() {
    return (String) getAttribute("site_fonts");
  }
  
  public static String getSiteIcon() {
    return (String) getAttribute("site_icon");
  }
  
  public static String getSiteWelcome() {
    return (String) getAttribute("site_welcome");
  }
  
  public static String getSiteInternalFiles() {
    return (String) getAttribute("site-files");
  }
  
  public static String getEncoding() {
    return (String) getAttribute("site_encoding");
  }
  
  public static String getContextLoad() {
    return (String) getAttribute("site_context-load");
  }
  
  public static String getSiteLocales() {
    return (String) getAttribute("site_locales");
  }
  
  public static boolean isValidLocale(Locale locale) {
    return getSiteLocales().contains(locale.getLanguage());
  }
 
  public static String getSiteSignin() {
    return (String) getAttribute("site_signin");
  }
  
  public static String getSiteSyndicate() {
    return (String) getAttribute("site_syndicate");
  }
  
  public static String getDirectoryQualification() {
    return (String) getAttribute("site_directory-qualification");
  }
  
  public static String getTemplatesRoot() {
    return (String) getAttribute("site_templatesRoot");
  }
  
  public static boolean getUseSSL() {
    return "true".equals((String) getAttribute("site_use-ssl"));
  }
  
  public static boolean getUseSSO() {
    return "true".equals((String) getAttribute("site_use-sso"));
  }
  
  public static boolean getLiveLinks() {
    return "true".equals((String) getAttribute("site_live-links"));
  }
  
  public static Locale getContactLocale() {
    return new Locale((String) getAttribute("contact_language"), (String) getAttribute("contact_country"));
  }
  
  public static Currency getContactCurrency() {
    return Currency.getInstance((String) getAttribute("contact_currency"));
  }
  
  public static boolean hasSignup() {
    return Folder.from(ElephantContext.getRealPath("/user/signup")).exists() &&
           "true".equals((String) getAttribute("site_has_signup"));
  }
 
  public static String getServerBase(String scheme) {
    if(scheme.equals("http") && getUseSSL()) {
      scheme = "https";
    }
    String server = schemes.get(scheme);
    if(server == null) {
      server = scheme + "://" + getSiteForcedDomain();
    }
    return server;
  }
  
  public static String getServerUrl(String scheme) {
    return getServerBase(scheme) + getRootWebPath();
  }
  
  public static URI toUri(String localPath) throws URISyntaxException {
    return new URI(getServerBase("http") + getRootWebPath() + localPath);
  }
  
  public static byte[] encrypt(byte[] value) {
    return Cipher.symetricEncrypt(value);
  }
 
  public static byte[] decrypt(byte[] value) {
    return (value != null && ((value.length % 8) == 0)) ? 
            Cipher.symetricDecrypt(value) : null;
  }
 
  public static String encrypt(String value) {
    return !Strings.isBlank(value) ? new String(
            new Base64().encode(encrypt(value.getBytes()))) : "";
  }
 
  public static String decrypt(String value) {
    if(!Strings.isBlank(value)) {
      byte[] bytes = decrypt(new Base64().decode(value.getBytes()));
      return bytes != null ? new String(bytes) : "";
    }
    return null;
  }
 
  public static File file(String path) {
    return new File(getRealPath(path));
  }
 
  public static String logMsg(String msg) {
    return "[" + getSiteName() + "]" + (Strings.isBlank(msg) ? "" : ": " + msg); 
  }
 
  public static void resetSite() {
    loadSiteConfiguration();
  }
  
  public static void resetSchemes() {
    schemes.clear();
  }
  
  private final static String
          SITE_FILE = "/WEB-INF/elephant/conf/site.xml";
 
  private static void loadSiteConfiguration() {
    Element conf = null;
    SAXBuilder builder = new SAXBuilder();
    Document doc;
    try {
      File confFile = new File(getRealPath(SITE_FILE));
      if(confFile.exists()) {
        doc = builder.build(confFile);
        conf = doc.getRootElement();
      }
      if(conf != null) {
        setAttribute("site_name", readAttribute(conf.getChild("name"), "value", "Elephant"));
        setAttribute("site_forced-domain", conf.getChildText("force-domain"));
        setAttribute("site_description", conf.getChildText("description"));
        setAttribute("site_keywords", conf.getChildText("keywords"));
        setAttribute("site_fonts", conf.getChildText("fonts"));
        setAttribute("site_icon", conf.getChildText("icon"));
        setAttribute("site_welcome", conf.getChildText("welcome"));
        setAttribute("site_internal-files", conf.getChildText("internalFiles"));
        setAttribute("site_encoding", readAttribute(conf.getChild("encoding"), "value", "ISO-8859-1"));
        setAttribute("site_context-load", readAttribute(conf.getChild("context-load"), "value", "none"));
        setAttribute("site_locales", readAttribute(conf.getChild("locales"), "value", "_en,_ca"));
        setAttribute("site_use-ssl", conf.getChildText("use-ssl"));
        setAttribute("site_use-sso", Strings.isBlank(conf.getChildText("use-sso"), "true"));
        setAttribute("site_live-links", Strings.isBlank(conf.getChildText("live-links"), "true"));
        String gs = conf.getChildText("syndicate");
        setAttribute("site_syndicate", Strings.isBlank(gs) ? "Guests" : gs);
        String qualification = conf.getChildText("directory-qualification");
        setAttribute("site_directory-qualification", Strings.isBlank(qualification) ? "any,!guest" : qualification);
        setAttribute("rootWebPath", getRootWebPath());
        String tmplRoot = conf.getChildText("templates-root");
        setAttribute("site_templatesRoot", Strings.isBlank(tmplRoot) ? "templates" : tmplRoot);
        setAttribute("site_has_signup", Strings.isBlank(conf.getChildText("has-signup"), "true"));
        String signin = conf.getChildText("signin");
        setAttribute("site_signin", signin);
        if(Strings.isBlank(signin) || "all".equals(signin)) {
          setAttribute("signPersona", true);
          setAttribute("signInternal", true);
        } else if("persona".equals(signin)) {
          setAttribute("signPersona", true);
          setAttribute("signInternal", false);
        } else if("internal".equals(signin)) {
          setAttribute("signPersona", false);
          setAttribute("signInternal", true);
        }
        _metas = new ArrayList<>();
        for(Element meta : (List<Element>) conf.getChildren("meta")) {
          _metas.add(new XMLOutputter().outputString(meta));
        }
        setAttribute("contact_language", readAttribute(conf.getChild("contact-defaults"), "language", "ca"));
        setAttribute("contact_country", readAttribute(conf.getChild("contact-defaults"), "country", "ES"));
        setAttribute("contact_currency", readAttribute(conf.getChild("contact-defaults"), "currency", "EUR"));
      }
    } catch (IOException | JDOMException ex) {
      Logger.getLogger(ElephantContext.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
  
  private static String readAttribute(Element child, String attr, String def) {
    return child != null ? child.getAttributeValue(attr) : def;
  }
  
  private static final HashMap<String, String> schemes = new HashMap<>();
  
  public static void initServerSchemas(HttpServletRequest request) {
    if(!schemes.containsKey(request.getScheme())) {
      schemes.put(request.getScheme(), request.getScheme() + "://" +
              request.getServerName() + getServerPort(request));
    }
  }
  
  private static String getServerPort(HttpServletRequest request) {
    String scheme = request.getScheme();
    int port = request.getServerPort();
    if("http".equals(scheme) && port == 80) {
      return "";
    } else if("https".equals(scheme) && port == 443) {
      return "";
    } else if("ftp".equals(scheme) && port == 21) {
      return "";
    }
    return ":" + port;
  }
  
  /* Entity's context */
  
  private static final String ENTITY_WEB_CONTEXT = "entity-web-context";
  
  public static String getEntityWebContext(String path) {
    String[] paths = path.split(",");
    for(String p : paths) {
      String ep = getEntityWebContext(new Path(p));
      if(!Strings.isBlank(ep)) {
        return ep;
      }
    }
    return null;
  }
  
  public static String getEntityWebContext(Path path) {
    return ElephantProperties.getContextProperty(ENTITY_WEB_CONTEXT, path.getRoot());
  }
 
//  /* Annotations */
//  
//  private static final Lock classesLock = new ReentrantLock();
//  private static final Lock instancesLock = new ReentrantLock();
//  private static Map<String, Set<String>> annotatedClasses;
//  private static Map<String, Set<Object>> annotatedInstances;
//
//  public static <T> T getInstanceByAnnotation(Class annotationClass, Class<T> type) {
//    return getInstanceByAnnotation(annotationClass, type, false);
//  }
//
//  public static <T> T getInstanceByAnnotation(Class annotationClass, Class<T> type, boolean fresh) {
//    Set<T> instances = ElephantContext.getInstancesByAnnotation(annotationClass, type, fresh);
//    if(instances != null && !instances.isEmpty()) {
//      return instances.iterator().next();
//    }
//    return null;
//  }
//
//  public static <T> Set<T> getInstancesByAnnotation(Class annotationClass, Class<T> type) {
//    return getInstancesByAnnotation(annotationClass, type, false);
//  }
//  
//  public static <T> Set<T> getInstancesByAnnotation(Class annotationClass, Class<T> type, boolean fresh) {
//    if(annotatedInstances == null) {
//      annotatedInstances = new HashMap<>();
//    }
//    Set<T> instances = (Set<T>) annotatedInstances.get(annotationClass.getName());
//    if(fresh || instances == null) {
//      instancesLock.lock();
//      try {
//        instances = (Set<T>) annotatedInstances.get(annotationClass.getName());
//        if(fresh || instances == null) {
//          instances = new HashSet<>();
//          for(String className : getClassesByAnnotation(annotationClass.getName())) {
//            Class javaClass = ReflectionUtil.classCheck(className);
//            if(javaClass != null && ReflectionUtil.canCast(javaClass, type)) {
//              T instance = (T) ReflectionUtil.instance(javaClass);
//              if(instance != null) {
//                instances.add(instance);
//              }
//            }
//          }
//          annotatedInstances.put(annotationClass.getName(), (Set<Object>) instances);
//        }
//      } finally {
//        instancesLock.unlock();
//      }
//    }
//    return instances;
//  }
//  
//  public static Set<String> getClassesByAnnotation(Class annotationClass) {
//    return getClassesByAnnotation(annotationClass.getName());
//  }
//  
//  public static Set<String> getClassesByAnnotation(String annotationClass) {
//    if(annotatedClasses == null) {
//      annotatedClasses = new HashMap<>();
//    }
//    Set<String> classes = annotatedClasses.get(annotationClass);
//    if(classes == null) {
//      classesLock.lock();
//      try {
//        classes = annotatedClasses.get(annotationClass);
//        if(classes == null) {
//          classes = new HashSet<>();
//          annotatedClasses.put(annotationClass, classes);
//          classes.addAll(ClassNames.cached()
//                  .packages("org.turro")
//                  .byAnnotation(annotationClass));
//        }
//      } finally {
//        classesLock.unlock();
//      }
//    }
//    return classes;
//  }
//  
//  public static void clearAnnotatedClasses() {
//    annotatedClasses = null;
//  }
//  
//  /* Subclasses */
//  
//  private static final Lock subclassLock = new ReentrantLock();
//  private static Map<String, Set<String>> subClasses;
//  private static Map<String, Set<Object>> subInstances;
//  
//  public static <T> Set<T> getInstancesBySuperclass(Class superClass, Class<T> type) {
//    return getInstancesBySuperclass(superClass, type, false);
//  }
//  
//  public static <T> Set<T> getInstancesBySuperclass(Class superClass, Class<T> type, boolean fresh) {
//    if(subInstances == null) {
//      subInstances = new HashMap<>();
//    }
//    Set<T> instances = (Set<T>) subInstances.get(superClass.getName());
//    if(fresh || instances == null) {
//      subclassLock.lock();
//      try {
//        instances = (Set<T>) subInstances.get(superClass.getName());
//        if(fresh || instances == null) {
//          instances = new HashSet<>();
//          for(String javaClass : getClassesBySuperclass(superClass.getName())) {
//            Class jClass = ReflectionUtil.classCheck(javaClass);
//            if(jClass != null && ReflectionUtil.canCast(jClass, type)) {
//              T instance = (T) ReflectionUtil.instance(jClass);
//              if(instance != null) {
//                instances.add(instance);
//              }
//            }
//          }
//          subInstances.put(superClass.getName(), (Set<Object>) instances);
//        }
//      } finally {
//        subclassLock.unlock();
//      }
//    }
//    return instances;
//  }
//  
//  public static Set<String> getClassesBySuperclass(String superClass) {
//    if(subClasses == null) {
//      subClasses = new HashMap<>();
//    }
//    Set<String> classes = subClasses.get(superClass);
//    if(classes == null) {
//      subclassLock.lock();
//      try {
//        classes = subClasses.get(superClass);
//        if(classes == null) {
//          classes = new HashSet<>();
//          subClasses.put(superClass, classes);
//          classes.addAll(ClassNames.cached()
//                  .packages("org.turro")
//                  .bySuper(superClass));
//        }
//      } finally {
//        subclassLock.unlock();
//      }
//    }
//    return classes;
//  }  
  
  /* Constructor */
  
  public static IConstructor getConstructor(HttpServletRequest request, HttpServletResponse response) {
    IConstructor impl = CollectionUtil.from(Instances.fresh().byAnnotation(ElephantConstructor.class, IConstructor.class)).first();
    if(impl != null) {
      impl.setRequest(request);
      impl.setResponse(response);
    }
    return impl;
  }
  
}