ElephantMarker.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.marker;
 
import freemarker.template.Configuration;
import freemarker.template.DefaultObjectWrapperBuilder;
import freemarker.template.Template;
import freemarker.template.TemplateException;
import freemarker.template.TemplateExceptionHandler;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.turro.string.Strings;
import org.turro.action.EntityInfoContent;
import org.turro.action.EntityInfoType;
import org.turro.action.LinkType;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.History;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.direct.DirectContents;
import org.turro.i18n.I_;
 
public class ElephantMarker extends Configuration {
 
  private static final String TEMPLATE_DIR = "/WEB-INF/elephant/";
  
  private IConstructor constructor;
  private final Map root = new HashMap();
  
  public ElephantMarker() {
    this(ElephantContext.createConstructor());
  }
 
  public ElephantMarker(IConstructor constructor) {
    this(constructor, false);
  }
  
  public ElephantMarker(IConstructor constructor, boolean mail) {
    this.constructor = constructor;
    try {
      setDirectoryForTemplateLoading(new File(templateRoot(constructor, mail)));
      DefaultObjectWrapperBuilder dowb = new DefaultObjectWrapperBuilder(VERSION_2_3_30);
      dowb.setForceLegacyNonListCollections(false);
      setObjectWrapper(dowb.build());
      setLocale(I_.api().used());
      setDefaultEncoding(ElephantContext.getEncoding());
      setOutputEncoding(ElephantContext.getEncoding());
      setDateFormat("short");
      setDateTimeFormat("short_short");
      setEncoding(I_.api().used(), ElephantContext.getEncoding());
      setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER);
      setURLEscapingCharset("UTF-8");
      setAPIBuiltinEnabled(true);
      root.put("constructor", constructor);
      root.put("history", History.getInstance(constructor));
      root.put("repository", IConstructor.currentRepository(constructor));
      root.put("grepository", IConstructor.globalRepository());
      root.put("serverURL", ElephantContext.getServerUrl("http"));
      root.put("rootWebPath", ElephantContext.getRootWebPath());
      root.put("siteName", ElephantContext.getSiteName());
      root.put("labels", I_.compatibilityMap());
      root.put("i_", I_.api());
      root.put("i", I_.map());
      root.put("k", I_.byKeyMap());
      root.put("infoLink", EntityInfoContent.createURL(EntityInfoType.FULL, LinkType.WEB));
      root.put("logoutURL", DirectContents.createRelativeURL("authentication") + "/logout");
      root.put("helper", new MarkerHelper(constructor));
      ContactIdentity identity = new ContactIdentity();
      root.put("identity", identity);
      root.put("rolemap", identity.getPermissionMap());
      root.put("cookies", new Cookies(constructor.getRequest(), constructor.getResponse()));
      if(getLocale() != null) {
        root.put("lang", getLocale().getLanguage());
      }
      ElephantHelpers.addToMap(root);
    } catch (IOException ex) {
      Logger.getLogger(ElephantMarker.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
 
  public IConstructor getConstructor() {
    return constructor;
  }
 
  public Map getRoot() {
    return root;
  }
  
  public String parse(String rootTmpl, String tmpl) {
    StringWriter sw = new StringWriter();
    process(rootTmpl, tmpl, sw);
    return sw.toString();
  }
 
  public void process(String rootTmpl, String tmpl) {
    try {
      process(rootTmpl, tmpl, constructor.getOut());
    } catch (IOException ex) {
      Logger.getLogger(ElephantMarker.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
 
  public void process(String rootTmpl, String tmpl, Writer out) {
    try {
      Template template = null;
      try {
        template = getTemplate(getSiteTemplateString(rootTmpl, tmpl));
      } catch(FileNotFoundException ex) {
        template = getTemplate(getTemplateString(rootTmpl, tmpl));
      }
      template.process(root, out);
    } catch (IOException | TemplateException ex) {
      //MailError.getInstance(ElephantMarker.class, ex, tmpl)
      //        .sendEmail(Application.getApplication());
      Logger.getLogger(ElephantMarker.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }    
  }
 
  public Object get(Object key) {
    return root.get(key);
  }
 
  public Object put(Object key, Object value) {
    return root.put(key, value);
  }
 
  public Object remove(Object key) {
    return root.remove(key);
  }
 
  public boolean contains(Object key) {
    return root.containsKey(key);
  }
  
  public void putAll(Map m) {
    root.putAll(m);
  }
  
  public String getTemplateString(String root, String template) {
    if(!Strings.isBlank(template)) {
      if(!template.contains("/")) {
        template = "/" + root + "/" + template + "Template.html";
      }
    }
    return template;
  }
  
  public String getSiteTemplateString(String root, String template) {
    if(!Strings.isBlank(template)) {
      if(!template.contains("/")) {
        template = "/" + root + "/site/" + template + "Template.html";
      }
    }
    return template;
  }
  
  public static boolean existsTemplate(IConstructor constructor, boolean mail, String root, String name) {
    return existsTemplate(constructor, mail, root, name, false);
  }
  
  public static boolean existsTemplate(IConstructor constructor, boolean mail, String root, String name, boolean overriden) {
    return fileTemplate(constructor, mail, root, name, overriden).exists();
  }
  
  public static File fileTemplate(IConstructor constructor, boolean mail, String root, String name) {
    return fileTemplate(constructor, mail, root, name, false);
  }
  
  public static File fileTemplate(IConstructor constructor, boolean mail, String root, String name, boolean overriden) {
    StringBuilder sb = new StringBuilder(templateRoot(constructor, mail));
    sb.append("/").append(root).append("/");
    if(overriden) sb.append("site").append("/");
    sb.append(name).append("Template.html");
    return new File(sb.toString());
  }
  
  public static String templateRoot(IConstructor constructor, boolean mail) {
    if(mail) {
      return ElephantContext.getRealPath(TEMPLATE_DIR + "templates-mail");
    } else if(constructor != null) {
      return ElephantContext.getRealPath(TEMPLATE_DIR + constructor.getTemplateRoot());
    } else {
      return ElephantContext.getRealPath(TEMPLATE_DIR + ElephantContext.getTemplatesRoot());
    }
  }  
 
}