Application.java

Go to the documentation of this file.

/*
 * Turró i Cutiller Foundation. License notice.
 * Copyright (C) 2011 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.IOException;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.turro.annotation.ElephantSessionResolver;
import org.turro.elephant.impl.context.ContextFactory;
import org.turro.elephant.impl.security.UserPreferences;
import org.turro.elephant.impl.util.CookieUtil;
import org.turro.elephant.sitemap.SitemapGenerator;
import org.turro.elephant.web.ElContextMap;
import org.turro.i18n.I_;
import org.turro.i18n.Labels;
import org.turro.i18n.locale.I18nLocales;
import org.turro.plugin.contacts.IContact;
import org.turro.reflection.Instances;
import org.turro.security.SecurityGroups;
import org.turro.string.Strings;
 
public abstract class Application {
 
  public static final String[] BUNDLES = {
        "lang",
        "elephant",
        "labels",
        "documentation",
        "label-site"
  };
  public static final String REGEXP_NO_RESOURCES = "(\\/zkau.*|\\/app.*)";
 
  /*
  Create 2 app: elapp and bsapp. 
  ElephantApplication will use with preference elapp and when not available bsapp.
  BrightSideApplication will use with preference bsapp, checking isAvailable() using Executions.getCurrent() != null.
  */
  protected static ThreadLocal<Application> app = new ThreadLocal<>();
 
  protected UserPreferences preferences;
  protected HttpServletRequest request; 
  protected HttpServletResponse response;
  
  public static Application getApplication() {
    Application application = app.get();
    try {
      if(application == null) {
        HttpServletRequest request = getResolverRequest();
        if(request != null) {
          if(application == null) {
            application = (Application) request.getAttribute("el_app");
          }
          if(application == null) {
            application = new ElephantApplication(request, getResolverResponse());
            request.setAttribute("el_app", application);
          }
        }
      }
      if(application != null) {
        app.set(application);
        return application;
      } else {
        return HeadlessApplication.getInstance();
      }
    } catch(Exception ex) {
      return HeadlessApplication.getInstance();
    }    
  }
 
  public static Application getFromConstructor(IConstructor constructor) {
    return (Application) constructor.getRequest().getAttribute("el_app");
  }
  
  public static boolean loadResources(String path) {
    return !Strings.isBlank(path) && !path.matches(REGEXP_NO_RESOURCES);
  }
  
  public static void resetSettings() {
    SecurityGroups.reset();
    ContextFactory.resetImplementationsStartingWith("IMail");
    ElephantContext.resetSite();
    ElephantProperties.resetProperties();
    Labels.resetMaps();
    I_.resetMaps();
    ElContextMap.reset();
    SitemapGenerator.generateSitemap();
  }
  
  public static void resetSchemes() {
    ElephantContext.resetSchemes();
  }
  
  public Application() {
    // move request and response here
    /*if(app.get() == null)*/ 
    if(!(this instanceof HeadlessApplication)) {
      app.set(this);
    }
  }
 
  public ApplicationContext getContext() {
    return new ApplicationContext(
            getHttpServletRequest(),
            getHttpServletResponse());
  }
 
  public boolean hasAnyRoleKey(String role) {
    IConstructor constructor = getConstructor();
    return constructor.hasAnyRoleKey(role);
  }
 
  public boolean isInRole(String role) {
    try {
      return isInRole(role, null);
    } catch (IOException ex) {
      Logger.getLogger(Application.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return false;
  }
 
  public boolean isInRole(String role, String redirect) throws IOException {
    IConstructor constructor = getConstructor();
    boolean result, isWebAdministering = constructor.isWebAdministering();
    if(!isWebAdministering) {
      constructor.setWebAdministering(true);
    }
    result = constructor.isInRole(role);
    if(!isWebAdministering) {
      constructor.setWebAdministering(false);
    }
    if(!result && redirect != null) {
      constructor.redirect(redirect);
    }
    return result;
  }
 
  public static IContact getUser() {
    return getApplication().getConstructor().getUser();
  }
  
  public IContact checkUser(boolean doLogin) throws IOException {
    IConstructor constructor = getConstructor();
    IContact user = constructor.getUser();
    if(user == null && doLogin) {
      ElephantLogin.redirectToLogin(constructor);
    }
    return user;
  }
 
  public Object getPreference(String key) {
    try {
      IContact user = checkUser(false);
      if (user != null) {
        if (preferences == null || !preferences.isEqual(user.getId())) {
          preferences = UserPreferences.getInstance(user.getId());
        }
        return preferences.get(key);
      }
    } catch (IOException ex) {
      Logger.getLogger(Application.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return null;
  }
 
  public void putPreference(String key, Object value) {
    try {
      IContact user = checkUser(false);
      if (user != null) {
        if (preferences == null || !preferences.isEqual(user.getId())) {
          preferences = UserPreferences.getInstance(user.getId());
        }
        preferences.put(key, value);
      }
    } catch (IOException ex) {
      Logger.getLogger(Application.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
 
  public IConstructor getConstructor() {
    IConstructor elcons = null;
    if(getHttpServletRequest() != null) {
      elcons = (IConstructor) getHttpServletRequest().getAttribute("el_cons");
    }
    if(elcons == null) {
      elcons = doConstructor();
    }
    return elcons;
  }
 
  public void invalidateSession() {
    // check why Application.get() request has no session
    try {
      getHttpSession(false).invalidate();
    } catch(Exception ex) {
      getResolverSession(true).invalidate();
    }
  }
 
  public HttpSession getHttpSession(boolean create) {
    if(getHttpServletRequest() != null) {
      return getHttpServletRequest().getSession(create);
    }
    return null;
  }
 
  public IImplementation getImplementation(String name) {
    return (IImplementation) ContextFactory.getImplementation(getConstructor(), name);
  }
 
  public List getImplementationNamesByType(String type) {
    return ContextFactory.getImplementationNamesByType(type);
  }
 
  public abstract HttpServletRequest getHttpServletRequest();
  public abstract HttpServletResponse getHttpServletResponse();
  public abstract void sendRedirect(String uri);
  public abstract void navigateBack();
  protected abstract IConstructor doConstructor();
  
  // Cookies
  
  public static Cookie getCookie(String name) {
    return CookieUtil.getCookie(getApplication().getHttpServletRequest(), name);
  }
 
  public static String getCookieValue(String name) {
    Cookie c = getCookie(name);
    return c != null ? c.getValue() : null;
  }
 
  public static void setCookie(String name, String value, String path, int age) {
    CookieUtil.setCookie(getApplication().getHttpServletResponse(), name, value, path, age);
  }
 
  public static void encryptCookie(String name, String value, String path, int age) {
    try {
      byte[] b = ElephantContext.encrypt(value.getBytes());
      CookieUtil.encryptCookie(getApplication().getHttpServletResponse(), name, b, path, age);
    } catch (Exception ex) {
      Logger.getLogger(Application.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
 
  public static String decryptCookieValue(String name) {
    try {
      Cookie cookie = getCookie(name);
      if(cookie != null) {
        byte[] v = CookieUtil.decryptCookieValue(cookie);
        if(v != null) return new String(ElephantContext.decrypt(v));
      }
    } catch (Exception ex) {
      Logger.getLogger(Application.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return null;
  }
 
  public static void deleteCookie(String name, String path) {
    CookieUtil.deleteCookie(getApplication().getHttpServletResponse(), name, path);
  }
 
  /* Labels */
  
  public static Locale getUsedLocale() {
    return I_.api().used();
  }
    
  public static Map getStringMap() {
    return I_.compatibilityMap();
  }
  
  public static Map getStringMap(Locale locale, String configured) {
    return I_.compatibilityMap(locale);
  }
  
  public static String getString(String key) {
    return I_.compatibility().get(key);
  }
  
  public static String getString(String key, String locale) {
    return I_.compatibility().get(I18nLocales.createLocale(locale), key);
  }
  
  public static String getString(String key, Locale locale) {
    return I_.compatibility().get(locale, key);
  }
  
  public static List<String> getAllLocales(String key) {
    return I_.compatibility().getInLocales(key);
  }
  
  public static ResourceBundle getBundle(String bundle, Locale locale, String configured) {
    return I_.compatibilityMap(locale).asBundle();
  }
  
  /* Context delegate */
  
  public String getServerBase() {
    return ElephantContext.getServerBase("http");
  }
  
  public String getServerUrl() {
    return ElephantContext.getServerUrl("http");
  }
  
  /* Session Resolvers */
  
  public static HttpServletRequest getResolverRequest() {
    for(ISessionResolver iSessionResolver : Instances.cached().byAnnotation(ElephantSessionResolver.class, ISessionResolver.class)) {
      HttpServletRequest request = iSessionResolver.getRequest();
      if(request != null) {
        return request;
      }
    }
    return null;
  }
  
  public static HttpServletResponse getResolverResponse() {
    for(ISessionResolver iSessionResolver : Instances.cached().byAnnotation(ElephantSessionResolver.class, ISessionResolver.class)) {
      HttpServletResponse response = iSessionResolver.getResponse();
      if(response != null) {
        return response;
      }
    }
    return null;
  }
  
  public static HttpSession getResolverSession(boolean create) {
    for(ISessionResolver iSessionResolver : Instances.cached().byAnnotation(ElephantSessionResolver.class, ISessionResolver.class)) {
      HttpSession session = iSessionResolver.getSession(create);
      if(session != null) {
        return session;
      }
    }
    return null;
  }
  
}