DefaultConstructor.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.impl.context;
 
import java.io.*;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.turro.string.Strings;
import org.jdom.Element;
import org.turro.action.Actions;
import org.turro.action.Parameters;
import org.turro.action.Secrets;
import org.turro.annotation.ElephantConstructor;
import org.turro.elephant.context.Application;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.ElephantLogin;
import org.turro.elephant.context.History;
import org.turro.elephant.context.IAction;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.context.MetaList;
import org.turro.elephant.impl.util.CookieUtil;
import org.turro.elephant.impl.util.FileUtil;
import org.turro.elephant.impl.util.Localizer;
import org.turro.elephant.impl.util.Parser;
import org.turro.elephant.security.IUser;
import org.turro.elephant.web.ElContext;
import org.turro.elephant.web.ElContextMap;
import org.turro.html.HtmlContent;
import org.turro.i18n.I_;
import org.turro.marker.ElephantMarker;
import org.turro.plugin.contacts.IContact;
import org.turro.util.IdGenerator;
 
@ElephantConstructor
public class DefaultConstructor implements IConstructor {
  
  protected final static String
          BUNDLE_LOCATION = "/WEB-INF/classes/elephant.properties";
  protected HttpServletRequest request;
  protected HttpServletResponse response;
  protected ElContext rendering = null, currentContext = null;
  protected Properties bundle = null;
  protected PrintWriter out = null;
  protected StringWriter stringOutput = null;
  protected ArrayList metas = new ArrayList(), headers = new ArrayList(), footers = new ArrayList();
  protected boolean isAContext = false, pageRendering = true, nullOutput = false;
  protected String stopper;
  protected boolean hasMootools = false, hasPrototype = false;
 
  private int uniqueSuffix = 0;
 
  public DefaultConstructor() {
    ElContextMap.init();
  }
 
  @Override
  public boolean isHeadless() {
    return request == null;
  }
  
  @Override
  public void setRequest(ServletRequest request) {
    this.request = (HttpServletRequest)request;
    if(this.request != null) {
      this.request.setAttribute("el_cons", this);
      if(Application.loadResources(((HttpServletRequest) request).getServletPath())) {
        this.request.setAttribute("el_label", I_.compatibilityMap());
        this.request.setAttribute("i_", I_.api());
        this.request.setAttribute("i", I_.map());
        this.request.setAttribute("k", I_.byKeyMap());
      }
    }
  }
  
  @Override
  public void setResponse(ServletResponse response) {
    this.response = (HttpServletResponse)response;
    if(this.response != null)
      CookieUtil.setCookie((HttpServletResponse) response, "webroot", request.getContextPath(), "/", 30*24*60*60);
  }
  
  @Override
  public HttpServletRequest getRequest() {
    return request;
  }
  
  @Override
  public HttpServletResponse getResponse() {
    return response;
  }
  
  @Override
  public ElContext getCurrentContext() {
    if(currentContext == null)
      currentContext = ElContextMap.getContext(this);
    return currentContext;
  }
  
  @Override
  public ElContext getRenderingContext() {
    if(rendering == null) return getCurrentContext();
    return rendering;
  }
  
  @Override
  public void setRenderingContext(ElContext context) {
    rendering = context;
  }
 
  @Override
  public void forceIsAContext(ElContext context) {
    currentContext = context;
    isAContext = true;
  }
 
  @Override
  public boolean isOriginal() {
    return getCurrentContext().equals(getRenderingContext());
  }
  
  @Override
  public boolean isFileInternal(File file) {
    if(file == null) return true;
    String fileName = file.isFile() ? file.getName() : file.getAbsolutePath();
    String internals = ElephantContext.getSiteInternalFiles();
    if(internals != null) {
      String tmp[] = internals.split(",");
      for(String s : tmp) {
        if(fileName.matches(Strings.convertToRegEx(s))) return true;
      }
    }
    return (fileName.matches("google.*\\.html")) ||
            (fileName.matches("site.*\\.xml")) ||
            (fileName.matches("robots\\.txt")) ||
            (fileName.contains("_internal")) ||
            (fileName.contains("_zul")) ||
            (fileName.contains("resources")) ||
            (fileName.contains("WEB-INF")) ||
            (fileName.contains("META-INF"));
  }
  
  @Override
  public Object findAttribute(String key) {
    Object value = getRequestAttribute(key);
    if(value == null) value = getSessionAttribute(key);
    if(value == null) value = getApplicationAttribute(key);
    return value;
  }
  
  @Override
  public Object getApplicationAttribute(String key) {
    return ElephantContext.getAttribute(key);
  }
  
  @Override
  public Object getSessionAttribute(String key) {
    try {
      if(request != null && request.getSession(false) != null) {
        return request.getSession().getAttribute(key);
      }
    } catch(Exception ex) {
      Logger.getLogger(DefaultConstructor.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return null;
  }
  
  @Override
  public Map<String, Object> getSessionAttributeMap(String prefix) {
    HashMap<String, Object> map = new HashMap<>();
    try {
      if(request != null && request.getSession(false) != null) {
        HttpSession session = request.getSession();
        Iterator<String> it = session.getAttributeNames().asIterator();
        while(it.hasNext()) {
          String key = it.next();
          if(Strings.isBlank(prefix) || key.startsWith(prefix)) {
            map.put(Strings.killPrefix(key, prefix), session.getAttribute(key));
          }
        }
      }
    } catch(Exception ex) {
      Logger.getLogger(DefaultConstructor.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return map;
  }
  
  @Override
  public Object getRequestAttribute(String key) {
    return request != null ? request.getAttribute(key) : null;
  }
  
  @Override
  public void setApplicationAttribute(String key, Object value) {
    ElephantContext.setAttribute(key, value);
  }
  
  @Override
  public void setSessionAttribute(String key, Object value) {
    try {
      if(request != null && request.getSession() != null) request.getSession().setAttribute(key, value);
    } catch(Exception ex) {
      Logger.getLogger(DefaultConstructor.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
  
  @Override
  public void setRequestAttribute(String key, Object value) {
    try {
      if(request != null && request.getRequestURI() != null) request.setAttribute(key, value);
    } catch(Exception ex) {
      Logger.getLogger(DefaultConstructor.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
  
  @Override
  public void removeApplicationAttribute(String key) {
    ElephantContext.removeAttribute(key);
  }
  
  @Override
  public void removeSessionAttribute(String key) {
    try {
      if(request != null && request.getSession(false) != null) request.getSession().removeAttribute(key);
    } catch(Exception ex) {
      Logger.getLogger(DefaultConstructor.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
  
  @Override
  public void removeRequestAttribute(String key) {
    try {
      if(request != null) request.removeAttribute(key);
    } catch(Exception ex) {
      Logger.getLogger(DefaultConstructor.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
  
  @Override
  public void startConstruction() throws IOException, ServletException {
    boolean include = request.getServletPath().startsWith("/xp"),
            action = request.getServletPath().startsWith("/xpaction");
    
    if(Actions.executeAction(this)) return;
    
    Element incNode = null;
    //if(checkRedirections()) return;
    if(include) {
      incNode = ContextFactory.getInclude(this);
    }
    if(action) {
      //TODO: check permissions
      request.setAttribute("el_cons", this);
      IAction exec = ContextFactory.getAction(this);
      try {
        exec.execute();
      } catch (Exception ex) {
        throw new ServletException(ex);
      }
    } else {
      request.setAttribute("el_cons", this);
      if(incNode != null) {
        Iterator heads = incNode.getChildren("header").iterator();
        Element tmp;
        while(heads.hasNext()) {
          tmp = (Element) heads.next();
          switch (tmp.getAttributeValue("type")) {
            case "css":
              addCSS(tmp.getAttributeValue("content"));
              break;
            case "javascript":
              addJavaScript(tmp.getAttributeValue("content"));
              break;
          }
        }
      }
      if(incNode != null) {
        //TODO: check permissions
        includeContent(incNode.getAttributeValue("content"));
      } else {
        if(getCurrentContext() == null || !getCurrentContext().getFile().exists()) {
          redirect("/");
          return;
        } else {
          if(!Strings.isBlank(getCurrentContext().getWebContext().getRedirect())) {
            if(getCurrentContext().isInRole()) {
              setLastReferringContext(getCurrentContext().getPath());
              redirect(getCurrentContext().getWebContext().getRedirect());
              return;
            } else if(getUser() == null) {
              ElephantLogin.redirectToLogin(this);
              return;
            } else {
              redirect(getLastReferringContext());
              return;
            }
          } else {
            if(getCurrentContext().isInRole()) {
              setLastReferringContext(getCurrentContext().getPath());
              isAContext = true;
              addOnLoadedJavaScript("webRoot = '" + ElephantContext.getRootWebPath() + "';");
              addOnLoadedJavaScript("webPort = " + getRequest().getServerPort() + ";");
              addOnLoadedJavaScript("pushPK = '" + Secrets.getSecret("key=push;pair=pk") + "';");
              IUser iuser = getUser();
              if(iuser != null) {
                addOnLoadedJavaScript("currentMail = '" + iuser.getProperty(IUser.CONNECTOR_EMAIL) + "';");
              } else {
                addOnLoadedJavaScript("currentMail = null;");
              }
              Boolean internalSignIn = (Boolean) getSessionAttribute(IUser.INTERNAL_SIGNIN);
              if(internalSignIn != null && internalSignIn) {
                addOnLoadedJavaScript("internalSignIn = true;");
              }
              getCurrentContext().construct(this);
            } else if(getUser() == null) {
              ElephantLogin.redirectToLogin(this);
              return;
            } else {
              redirect("/");
              return;
            }
          }
        }
      }
      endBody();
      closeOut();
    }
  }
 
  @Override
  public void setStopper(String stopper) {
    this.stopper = stopper;
  }
  
  @Override
  public boolean fileExists(String filePath) {
    File file = new File(ElephantContext.getRealPath(filePath));
    return file.exists();
  }
  
  @Override
  public void startBody() {
    response.setContentType("text/html;charset=" + ElephantContext.getEncoding());
    addCSS("https://fonts.googleapis.com/css?family=${site_fonts}");
    MetaList confMetas = new MetaList(ElephantContext.getMetas());
    confMetas.add("<meta http-equiv=\"content-type\" content=\"text/html; charset=" + ElephantContext.getEncoding() + "\">");
    confMetas.addAll(metas);
    if(getCurrentContext() != null) {
      addRobots(getCurrentContext());
      ElephantMarker marker = new ElephantMarker(this);
      marker.put("lang", I_.api().used().getLanguage());
      marker.put("title", HtmlContent.plain(getCurrentContext().getTitle() + " | " + ElephantContext.getSiteName(), 255));
      marker.put("metas", confMetas);
      marker.put("description", ElephantContext.getSiteDescription());
      marker.put("keywords", ElephantContext.getSiteKeywords());
      marker.put("icon", ElephantContext.getSiteIcon());
      marker.put("headers", headers);
      marker.put("isContext", isAContext);
      marker.process("elephant", "startHtml");
    }
  }
  
  @Override
  public void endBody() {
    if(getCurrentContext() != null) {
      ElephantMarker marker = new ElephantMarker(this);
      marker.put("footers", footers);
      marker.process("elephant", "endHtml");
    }
  }
  
  @Override
  public void includeContent(String path) throws ServletException, IOException {
    getOut();
    if(path.matches(".*\\.(htm|html)")) {
      includeFile(out, ElephantContext.getRealPath(path));
    } else if(path.matches(".*\\.(txt)")) {
      out.println("<pre>");
      includeFile(out, ElephantContext.getRealPath(path));
      out.println("</pre>");
    } else {
      ElephantContext.getCurrent().getRequestDispatcher(path).include(request, response);
    }
  }
  
  @Override
  public void renderContext(String path, String stopper) throws ServletException, IOException {
    ElContext ctx;
    if((ctx = ElContextMap.getContext(path)) != null) {
      ElContext tmpCtx = this.rendering;
      String tmpStop = this.stopper;
      setRenderingContext(ctx);
      setStopper("true".equals(stopper) ? "<end/>" : null);
      ctx.getElement().startConstruction();      
      setRenderingContext(tmpCtx);
      setStopper(tmpStop);
    }
  }
  
  @Override
  public void redirect(String path) throws IOException {
    if(Strings.isBlank(path)) path = "/";
    if(path.equals("*")) {
      ElContext ctx = ElContextMap.getCurrent();
      path = ctx != null ? ctx.getPath() : "/";
    }
    if(path.startsWith("http:") || path.startsWith("https:") || !path.startsWith("/") || 
            (!Strings.isBlank(request.getContextPath()) && path.startsWith(request.getContextPath() + "/"))) {
      response.sendRedirect(path);
    } else {
      response.sendRedirect(request.getContextPath() + path);
    }
  }
 
  @Override
  public void navigateBack() throws IOException {
    redirect(Strings.isBlank(History.back(this), "/"));
  }
 
  @Override
  public void reload() throws IOException {
    ElContext elctx = getCurrentContext();
    if(elctx != null) {
      redirect(elctx.getPath());
    }
  }
  
  @Override
  public PrintWriter getOut() throws IOException {
    if(out == null && !nullOutput) {
      out = response.getWriter();
      if(response.getContentType() == null && pageRendering) {
        startBody();
      }
    }
    return out;
  }
  
  @Override
  public void setOut(PrintWriter out) {
    this.out = out; 
  }
 
  @Override
  public void closeOut() throws IOException {
    if(out != null) out.close();
  }
  
  @Override
  public void setPageRendering(boolean value) {
    pageRendering = value;
  }
  
  @Override
  public void setNullOutput(boolean value) {
    nullOutput = value;
  }
  
  @Override
  public void setOutputToString() {
    stringOutput = new StringWriter();
    setOut(new PrintWriter(stringOutput));
  }
  
  @Override
  public String getOutputString() {
    if(stringOutput != null) {
      return stringOutput.toString();
    }
    return null;
  }
 
  @Override
  public void processOutput(String text) throws ServletException, IOException {
    processOutput(out, text);
  }
  
  @Override
  public void processOutput(PrintWriter newOut, String text) throws ServletException, IOException {
    Parser.processMacros(this, newOut, text);
  }
  
  @Override
  public String encodeURL(String url) {
    try {
      return URLEncoder.encode(url, "UTF-8");
    } catch (UnsupportedEncodingException ex) {
      Logger.getLogger(DefaultConstructor.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return url;
  }
  
  @Override
  public String decodeURL(String url) {
    try {
      if(url != null) return URLDecoder.decode(new String(url.getBytes(ElephantContext.getEncoding()), "UTF-8"), "UTF-8");
    } catch (UnsupportedEncodingException ex) {
      Logger.getLogger(DefaultConstructor.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
    return url;
  }
  
  @Override
  public String getParameter(String param) {
    return getParameter(param, false);
  }
  
  @Override
  public String getParameter(String param, boolean decode) {
    if(decode) {
      return decodeURL(request.getParameter(param));
    }
    return request.getParameter(param);
  }
  
  @Override
  public String[] getParameterValues(String param) {
    return request.getParameterValues(param);
  }
 
  @Override
  public Parameters getParameters() {
    return Parameters.from(request.getParameterMap());
  }
  
  @Override
  public String getActionParameter() {
    String value = getParameter("action");
    if(value == null) {
      String name;
      Enumeration pn = getRequest().getParameterNames();
      while(pn.hasMoreElements()) {
        name = (String) pn.nextElement();
        if(name.startsWith("action_") && getParameter(name) != null) {
          value = name.substring(7);
          break;
        }
      }
    }
    return value;
  }
  
  @Override
  public String getContextParameter() {
    return getParameter("context");
  }
  
  @Override
  public String getIdelParameter() {
    return getParameter("idel");
  }
  
  private void includeFile(PrintWriter out, String file) throws IOException, ServletException {
    if(FileUtil.existsFile(file)) {
      try (BufferedReader br = FileUtil.getBufferedFile(file)) {
        String str;
        while((str = br.readLine()) != null) {
          if(stopper != null && str.contains(stopper)) {
            processOutput(out, str.substring(0, str.indexOf(stopper)) + "\n");
            break;
          }
          processOutput(out, str + "\n");
        }
      }
    }
  }
  
  @Override
  public String getValidUrl(String name) {
    return name.replaceAll("[^a-zA-Z0-9\\.\\-\\/]", "_");
  }
  
  @Override
  public String getValidFileName(String name) {
    return name.replaceAll("[^a-zA-Z0-9\\.\\-]", "_");
  }
  
  @Override
  public Localizer getLocalizer() {
    return new Localizer(this);
  }
  
  private String transformString(String string, int mode) {
    if(string != null) {
      if(mode == 0) {
        return string;
      } else if(mode == 1) {
        return string.substring(0, 1).toUpperCase() + string.substring(1);
      } else if(mode == 2) {
        return string.toUpperCase();
      } else if(mode == 3) {
        return string.toLowerCase();
      }
    }
    return string;
  }
  
  @Override
  public IContact getUser() {
    return (IContact)findAttribute(IUser.LOGGED_USER);
  }
 
  @Override
  public boolean isOutsider() {
    IContact user = getUser();
    if(user != null && user.isValid()) {
      return user.isOutsider();
    }
    return false;
  }
 
  @Override
  public String getUniqueId() {
    return "cid_" + IdGenerator.generate() + uniqueSuffix++;
  }
  
  @Override
  public boolean isInRole(String role) {
    if(("lang:_" + I_.api().used().getLanguage()).equals(role)) {
      return true;
    }
    IUser user = getUser();
    if(user != null) {
      if("user:in".equals(role)) return true;
      if(isWebAdminRole(role) && !isWebAdministering()) return false;
      return user.isInRole(role);
    } else {
      return false;
    }
  }
  
  @Override
  public boolean hasAnyRoleKey(String role) {
    IUser user = getUser();
    if(user != null) {
      return user.hasAnyRoleKey(role);
    } else {
      return false;
    }
  }
  
  @Override
  public void setLastReferringContext(String context) {
    History.add(this, context);
    //setSessionAttribute("xp_ref_ctx", context);
  }
  
  @Override
  public String getLastReferringContext() {
    return Strings.isBlank(History.peek(this), "/");
  }
  
  @Override
  public void addHeader(String header) {
    header = header.replaceAll("\\{webRoot\\}", ElephantContext.getRootWebPath());
    headers.add(header);
  }
  
  @Override
  public void addCSS(String cssFile) {
    if(cssFile.contains("${site_fonts}")) {
      if(ElephantContext.getSiteFonts() != null) {
        String fonts[] = ElephantContext.getSiteFonts().split(",");
        for(String font : fonts) {
          String result =
                  "<link rel=\"stylesheet\" type=\"text/css\" href=\"" +
                  urlToFile(cssFile.replaceFirst("\\$\\{site\\_fonts\\}", font)) +
                  "\">";
          if(!headers.contains(result)) {
            headers.add(result);
          }
        }
      }
    } else {
      String result =
              "<link rel=\"stylesheet\" type=\"text/css\" href=\"" +
              urlToFile(cssFile) +
              "\">";
      if(!headers.contains(result)) {
        headers.add(result);
      }
    }
  }
  
  @Override
  public void addJavaScript(String jsFile) {
    String result =
            "<script type=\"text/javascript\" src=\"" +
            urlToFile(jsFile) +
            "\"></script>";
    if(!headers.contains(result)) {
      headers.add(result);
    }
  }
 
  @Override
  public void addMeta(String meta) {
    metas.add(meta);
  }
  
  public String urlToFile(String file) {
    if(file.startsWith("http:") || file.startsWith("https:")) {
      return file;
    }
    return ElephantContext.getRootWebPath() + file;
  }
  
  @Override
  public void addOnLoadedJavaScript(String script) {
    if(!footers.contains(script)) {
      footers.add(script);
    }
  }
  
  public void addRobots(ElContext context) {
    boolean noIndex = context.getWebContext().isNoIndex(),
            noFollow = context.getWebContext().isNoFollow();
    String content = noIndex ? "NOINDEX" : "";
    content = content + (content.length() > 0 && noFollow ? "," : "");
    content = content + (noFollow ? "NOFOLLOW" : "");
    content = (content.length() == 0 ? "ALL" : content);
    String result = "<META NAME=\"ROBOTS\" CONTENT=\"" + content + "\">";
    if(!headers.contains(result)) {
      headers.add(result);
    }
  }
  
  @Override
  public void invalidateSession() {
    request.getSession().invalidate();
  }
 
  @Override
  public void setMaxInactiveInterval(int interval) {
    HttpSession session = request.getSession();
    if(session != null) {
      session.setMaxInactiveInterval(interval);
    }
  }
 
  @Override
  public void changeCssHeaders(String from, String to) {
    int count = 0;
    for(String s : (List<String>) headers) {
      headers.set(count, s.replace(from, to));
      count++;
    }
  }
  
  @Override
  public boolean canWebAdminister() {
    IUser user = getUser();
    return user == null ? false :
          (user.isInRole("context:list") ||
           user.isInRole("default:edit"));
  }
 
  @Override
  public boolean isWebAdministering() {
    return "true".equals(getSessionAttribute("xp_webAdministering"));
  }
 
  @Override
  public void setWebAdministering(boolean value) {
    setSessionAttribute("xp_webAdministering", Boolean.toString(value));
  }
 
  private boolean isWebAdminRole(String role) {
    return role.startsWith("context") ||
            role.startsWith("default") ||
            role.startsWith("control-version") ||
            role.startsWith("maillist");
  }
 
  /* Template */
  
  private String templateRoot = null;
  
  @Override
  public String getTemplateRoot() {
    if(templateRoot == null) {
      if(getCurrentContext() != null) {
        templateRoot = getCurrentContext().getTemplateRoot();
      } else {
        templateRoot = ElephantContext.getTemplatesRoot();
      }
    }
    return templateRoot;
  }
  
  // i18n migration el_cons
  
  public Map getString() {
    return I_.compatibilityMap();
  }
  
}