FileUtil.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.util;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.FileChannel;
import java.nio.charset.Charset;
import java.util.Date;
import java.util.Locale;
import java.util.Properties;
import javax.servlet.ServletException;
import org.turro.string.ObjectString;
import org.turro.string.Strings;
import org.turro.collections.LinkedProperties;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IAction;
import org.turro.elephant.impl.abstracts.AbstractAction;
import org.turro.i18n.I_;
import org.turro.parser.wiki.WikiCompiler;
import org.turro.plugin.contacts.IContact;
 
public class FileUtil extends AbstractAction implements IAction {
  
  public static final String
          VALID_EXT_REGEXP = "\\.(jsp|html|htm|txt|zul|zhtml)",
          VALID_LOCALE_REGEXP = "(_[a-zA-Z]{2})?(_[a-zA-Z]{2})?(_[a-zA-Z]{2})?";
 
  public FileUtil() {
  }
 
  @Override
  public int execute() throws Exception {
    String context = getParameter("context"),
           file = getParameter("file"),
           lang = getParameter("lang"),
           action = getActionParameter();
 
    if("edit".equals(action)) {
      if(!constructor.isInRole("default:edit")) return IAction.ERROR;
      if(!(constructor.isInRole("lang:" + lang) || constructor.isInRole("lang:all"))) return IAction.ERROR;
    }
    else if("new".equals(action)) {
      if(!constructor.isInRole("default:new")) return IAction.ERROR;
      file = "000" + ObjectString.formatObject(new Date(), "yyyyMMddHHmmssSSS", false) + lang + ".html";
    }
    else if("delete".equals(action)) {
      if(!constructor.isInRole("default:delete")) return IAction.ERROR;
      removeFiles(context, crudeName(file));
      constructor.redirect(getRealContext(context));
      return IAction.DONE;
    }
    else if("preview".equals(action)) {
      if(!constructor.isInRole("default:edit")) return IAction.ERROR;
      if(!(constructor.isInRole("lang:" + lang) || constructor.isInRole("lang:all"))) return IAction.ERROR;
      createPreview();
      return IAction.DONE;
    }
 
    file = substituteLang(file, lang);
    
    File result = new File(ElephantContext.getRealPath(context + "/" + file));
    IContact user = constructor.getUser();
    String actual = crudeName(file) +
               "." +
               ObjectString.formatObject(new Date(), "yyyyMMddHHmmssSSS", false) +
               "." +
               user.getId() +
               lang +
               ".wiki";
    File wiki = new File(ElephantContext.getRealPath(context + "/" + actual));
   
    saveContent(wiki, result);
 
    constructor.redirect(getRealContext(context));
    return IAction.DONE;
  }
 
  private void createPreview() throws IOException, ServletException {
    String s = constructor.getParameter("body", true);
    if(s != null) {
      //constructor.addHeaders(ContextFactory.getFactoryElement("default-element"));
      constructor.getOut().print(
              "<INPUT align='right' type='button' value='" + 
              I_.get("Close") + 
              "' onClick='window.close()' /><hr />");
      constructor.getOut().print("<div class='default-element'><div class='default-body'>");
      constructor.processOutput(WikiCompiler.source(s).constructor(constructor).html());
      constructor.getOut().print("</div></div></body></html>");
    }
  }
  
  private void saveContent(File wiki, File result) throws IOException {
    String s = constructor.getParameter("body");
    if(s != null) {
      setContent(wiki, s);
      setContent(result, WikiCompiler.source(s).constructor(constructor).html());
    }
  }
 
  private void removeFiles(String context, String prefix) {
    File folder = new File(ElephantContext.getRealPath(context));
    File files[] = folder.listFiles();
    for(int i = 0; i < files.length; i++) {
      if(files[i].getName().matches(prefix + ".*")) {
        files[i].delete();
      }
    }
  }
 
  public static CharSequence getCharSequenceFile(String filename) throws IOException {
    FileInputStream fis = new FileInputStream(filename);
    FileChannel fc = fis.getChannel();
    ByteBuffer bbuf = fc.map(FileChannel.MapMode.READ_ONLY, 0, (int)fc.size());
    CharBuffer cbuf = Charset.forName(ElephantContext.getEncoding()).newDecoder().decode(bbuf);
    return cbuf;
  }
  
  public static BufferedReader getBufferedFile(String folder, String file) throws java.io.IOException {
    return getBufferedFile(folder + "/" + file);
  }
  
  public static BufferedReader getBufferedFile(String file) throws java.io.IOException {
    return getBufferedFile(new File(file));
  }
  
  public static BufferedReader getBufferedFile(File file) throws java.io.IOException {
    return new BufferedReader(new InputStreamReader(new FileInputStream(file), ElephantContext.getEncoding()));
  }
  
  public static OutputStreamWriter getFileWriter(String folder, String file) throws java.io.IOException {
    return getFileWriter(folder + "/" + file);
  }
  
  public static OutputStreamWriter getFileWriter(String file) throws java.io.IOException {
    return getFileWriter(new File(file));
  }
  
  public static OutputStreamWriter getFileWriter(File file) throws java.io.IOException {
    return getFileWriter(file, false);
  }
 
  public static OutputStreamWriter getFileWriter(File file, boolean append) throws java.io.IOException {
    return new OutputStreamWriter(new FileOutputStream(file, append), ElephantContext.getEncoding());
  }
 
  public static Properties getProperties(File file) throws java.io.IOException {
    Properties properties = new Properties();
    properties.load(new InputStreamReader(new FileInputStream(file), ElephantContext.getEncoding()));
    return properties;
  }
  
  public static Properties getOrderedProperties(File file) throws java.io.IOException {
    Properties properties = new LinkedProperties();
    properties.load(new InputStreamReader(new FileInputStream(file), ElephantContext.getEncoding()));
    return properties;
  }
  
  public static String substituteLang(String file, String lang) {
    String extension = file.substring(file.lastIndexOf("."));
    return file.replaceAll(VALID_LOCALE_REGEXP + VALID_EXT_REGEXP + "$", lang + extension);
  }
  
  public static String baseName(String file) {
    if(file.matches(".*" + VALID_EXT_REGEXP)) {
      String extension = file.substring(file.lastIndexOf("."));
      return file.replaceAll(VALID_LOCALE_REGEXP + VALID_EXT_REGEXP + "$", extension);
    }    
    return null;
  }
 
  public static String extension(String name) {
    int p = name.lastIndexOf(".");
    if(p > -1 && p < name.length()) {
      return name.substring(p + 1);
    }
    return null;
  }
 
  public static String crudeName(String file) {
    if(file.matches(".*" + VALID_EXT_REGEXP)) {
      return file.replaceAll(VALID_LOCALE_REGEXP + VALID_EXT_REGEXP + "$", "");
    }    
    return null;
  }
 
  public static Locale getLocale(String file) {
    file = file.substring(0, file.lastIndexOf("."));
    int p = file.indexOf("_");
    if(p > -1) {
      try {
        return Locale.forLanguageTag(file.substring(p + 1));
      } catch(Exception ex) {
        return Locale.ENGLISH;
      }
    } else {
      return Locale.ENGLISH;
    }
  }
  
  public static String getLang(String file) {
    file = file.substring(0, file.lastIndexOf("."));
    int p = file.indexOf("_");
    if(p > -1)
      return file.substring(p);
    else
      return "";
  }
  
  public static String getRealContext(String context) {
    int p;
    if((p = context.indexOf("/_internal")) > -1) {
      return context.substring(0, p);
    }
    return context;
  }
  
  public static String getContent(File file) throws IOException {
    if(file.exists()) {
      BufferedReader br = getBufferedFile(file);
      StringBuilder sb = new StringBuilder();
      String s;
      while((s = br.readLine()) != null) {
        sb.append(s);
      }
      br.close();
      return sb.toString();
    }
    return null;
  }
 
  public static String getContentWithLineBreaks(File file) throws IOException {
    if(file.exists()) {
      BufferedReader br = getBufferedFile(file);
      StringBuilder sb = new StringBuilder();
      String s;
      while((s = br.readLine()) != null) {
        sb.append(s);
        sb.append("\n");
      }
      br.close();
      return sb.toString();
    }
    return null;
  }
 
  public static void setContent(File file, String value) throws IOException {
    if(value != null) {
      OutputStreamWriter osw = getFileWriter(file);
      osw.write(value);
      osw.close();      
    }
  }
 
  public static void appendContent(File file, String value) throws IOException {
    if(value != null) {
      OutputStreamWriter osw = getFileWriter(file, true);
      osw.write(value);
      osw.close();      
    }
  }
 
  public static File getFolderFile(File file) {
    String filePath = file.getAbsolutePath();
    return new File(filePath.substring(0, filePath.lastIndexOf('/')));    
  }
  
  public static String checkFileName(File folder, String name) {
    return checkFileName(folder.getAbsolutePath(), name);
  }
  
  public static String checkFileName(String path, String name) {
    if(!path.contains("WEB-INF")) {
      name = Strings.unpunctuate(name);
    }
    return name;
  }
  
  public static boolean existsFile(String requestURI) {
    File f = new File(requestURI);
    return f.exists() && f.isFile();
  }
 
}