DocumentsRoot.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.documents;
 
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.Properties;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.amic.util.file.FileUtil;
import org.amic.util.string.Cipher;
import org.jdom.Element;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.security.IUser;
import org.turro.i18n.I_;
 
public class DocumentsRoot {
  private DocumentsBean docBean;
  private String realRoot, docsRoot, privateKey, selected;
  private Element configuration;
  
  public DocumentsRoot(DocumentsBean docBean, String realRoot, String relativeRoot, Element config) {
    this.docBean = docBean;
    this.realRoot = realRoot;
    this.docsRoot = realRoot + relativeRoot;
    this.configuration = config;
    privateKey = Cipher.digest(docsRoot, 30);
    docBean.setAttribute("@" + privateKey, docsRoot);
  }
 
  public Properties getPropertiesFromUser(IUser user) {
    File userFolder = new File(getPath() + "/" + user.getId());
    if(!userFolder.exists()) {
      userFolder.mkdirs();
      Properties props = new Properties();
      props.put("root.name", user.getName());
      savePropertiesTo(user.getId(), props);
      return props;
    }
    return getPropertiesFrom(user.getId());
  }
  
  public void savePropertiesToUser(Properties props, IUser user) {
    File userFolder = new File(getPath() + "/" + user.getId());
    if(!userFolder.exists()) {
      userFolder.mkdirs();
    }
    savePropertiesTo(user.getId(), props);
  }
  
  public Properties getPropertiesFrom(String folder) {
    return getDocumentsBean().getPropertiesFile(
            getPath() + "/" + folder + "/.docs.properties");
  }
  
  public void savePropertiesTo(String folder, Properties props) {
    getDocumentsBean().savePropertiesFile(props,
            getPath() + "/" + folder + "/.docs.properties");
  }
  
  public DocumentsBean getDocumentsBean() {
    return docBean;
  }
    
  public FileDocument getFileDocumentRoot() {
    return new FileDocument(this, null, docsRoot);
  }
  
  public void setFileDocumentSelected(String selected) {
    this.selected = selected;
  }
  
  public FileDocument getFileDocumentSelected() {
    return new FileDocument(this, null, docsRoot + selected);
  }
  
  public String getAttribute(String attrib) {
    return configuration != null ? configuration.getAttributeValue(attrib) : null;
  }
  
  public boolean getCanNew() {
    return docBean.getCanNew();
  }
  
  public boolean getCanDelete() {
    return docBean.getCanDelete();
  }
  
  public boolean getCanNewFolder() {
    return docBean.getCanNewFolder();
  }
  
  public boolean getCanDelFolder() {
    return docBean.getCanDelFolder();
  }
  
  public String getDownloadURL() {
    return docBean.getDownloadURL() + "?down_path=@" + privateKey;
  }
  
  public String getPath() {
    return realRoot;
  }
  
  public String getRelativePath(String path) {
    if(path.startsWith(docsRoot)) {
      return path.substring(docsRoot.length());
    }
    return path;
  }
  
  public Collection getInsertionPointsWrapped() {
    Vector v = new Vector();
    String pattern = getAttribute("insertionPattern");
    for(FileDocument fd : getFileDocumentRoot().getListFolders()) {
      if(pattern == null || fd.getName().matches(pattern)) {
        v.add(new FileDocumentWrapper(fd, true));
      }
    }
    return v;
  }
  
  public FileDocument[] getInsertionFolders() {
    Vector v = new Vector();
    String pattern = getAttribute("insertionPattern");
    for(FileDocument fd : getFileDocumentRoot().getListFolders()) {
      if(pattern == null || fd.getName().matches(pattern)) {
        v.add(fd);
      }
    }
    return (FileDocument[]) v.toArray(new FileDocument[0]);
  }
  
  public Collection<FileDocument> getNotValidated() {
    Vector v = new Vector();
    fillNotValidated(v, getFileDocumentRoot());
    return v;
  }
  
  private void fillNotValidated(Vector v, FileDocument root) {
    for (FileDocument fd : root.getNotValidated()) {
      if(fd.isHidden()) {
        v.add(fd);
      }
      else if (fd.isDirectory()) {
        fillNotValidated(v, fd);
      }
    }
  }
 
  public String readConfig(String property) {
    return getFileDocumentRoot().readConfig(property);
  }
 
  public String readRootConfig(String property) {
    Properties props = docBean.getPropertiesFile(realRoot + "/.docs.properties");
    if(props != null) {
      return props.getProperty(property);
    }
    return null;
  }
  
  public void addInsertionPoint(String ident, String name) {
    if(ident.matches(getAttribute("insertionPattern"))) {
      new File(getPath() + "/" +  ident).mkdirs();
      Properties props = new Properties();
      props.put("root.name", name);
      savePropertiesTo(ident, props);
      copyTemplate(ident);
      docBean.getMessages().addMessage(I_.get("Insertion point created"));
    }
    else {
      docBean.getMessages().addError(I_.get("Identifier error, does not match pattern"));
    }
  }
 
  private void copyTemplate(String ident) {
    try {
      String template = getAttribute("template");
      FileUtil.copy(getPath() + template, getPath() + "/" + ident);
    } catch (IOException ex) {
      Logger.getLogger(DocumentsRoot.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
 
}