DocumentsBean.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.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.TreeSet;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.commons.fileupload.FileItem;
import org.apache.commons.fileupload.FileItemFactory;
import org.apache.commons.fileupload.FileUploadException;
import org.apache.commons.fileupload.disk.DiskFileItemFactory;
import org.apache.commons.fileupload.servlet.ServletFileUpload;
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.turro.elephant.context.ElephantContext;
import org.turro.elephant.context.IConstructor;
import org.turro.elephant.impl.context.ContextFactory;
import org.turro.elephant.impl.util.Localizer;
import org.turro.elephant.impl.util.ProcessMessages;
import org.turro.elephant.security.IUser;
import org.turro.i18n.I_;
import org.turro.mail.impl.MailPool;
import org.turro.mail.impl.MailUser;
 
public class DocumentsBean {
 
  public static final String DOCS_CONFIGURATION = "/WEB-INF/elephant/conf/documents.xml";
  private IConstructor constructor;
  private String docsRoot;
  private String selectedUser, selectedInsertion, selectedFolder, selectedId, selectedRoot;
  private int mode = 1;
 
  public DocumentsBean() {
  }
 
  public void setConstructor(IConstructor constructor) {
    this.constructor = constructor;
    constructor.setSessionAttribute("xp_down_mime", ElephantContext.getRootWebPath() + "/_internal/system/mime");
    getMessages().clear();
    processParameters();
  }
 
  public IConstructor getConstructor() {
    return constructor;
  }
 
  public ProcessMessages getMessages() {
    return ProcessMessages.getInstance();
  }
 
  public DocumentsRoot[] getRealRoots() {
    ArrayList v = new ArrayList();
    Element config = getConfiguration();
 
    if (config != null) {
      DocumentsRoot userRoot;
      Iterator it = config.getChildren("root").iterator();
      Element el;
      while (it.hasNext()) {
        userRoot = null;
        el = (Element) it.next();
        if (el.getAttribute("role") == null || constructor.isInRole(el.getAttributeValue("role"))) {
          docsRoot = el.getTextTrim();
          userRoot = new DocumentsRoot(this, docsRoot, "", el);
          v.add(userRoot);
        }
      }
    }
 
    return (DocumentsRoot[]) v.toArray(new DocumentsRoot[0]);
  }
 
  public DocumentsRoot[] getRealRootsWithUser() {
    ArrayList v = new ArrayList();
    Element config = getConfiguration();
 
    if (config != null) {
      DocumentsRoot userRoot;
      Iterator it = config.getChildren("root").iterator();
      Element el;
      while (it.hasNext()) {
        userRoot = null;
        el = (Element) it.next();
        if (el.getAttribute("role") == null || constructor.isInRole(el.getAttributeValue("role"))) {
          if ("true".equals(el.getAttributeValue("appendUser"))) {
            docsRoot = el.getTextTrim();
            userRoot = new DocumentsRoot(this, docsRoot, "", el);
            v.add(userRoot);
          }
        }
      }
    }
 
    return (DocumentsRoot[]) v.toArray(new DocumentsRoot[0]);
  }
 
  public DocumentsRoot[] getDocumentRoots() {
    if (selectedUser == null && constructor.getUser() != null) {
      selectedUser = constructor.getUser().getId();
    }
    ArrayList v = new ArrayList();
    Element config = getConfiguration();
 
    if (config != null) {
      DocumentsRoot userRoot;
      Iterator it = config.getChildren("root").iterator();
      Element el;
      while (it.hasNext()) {
        userRoot = null;
        el = (Element) it.next();
        if (el.getAttribute("role") == null || constructor.isInRole(el.getAttributeValue("role"))) {
          docsRoot = el.getTextTrim();
          if ("true".equals(el.getAttributeValue("appendUser"))) {
            if (selectedUser != null) {
              userRoot = new DocumentsRoot(this, docsRoot, "/" + selectedUser, el);
              v.add(userRoot);
            }
          } else {
            userRoot = new DocumentsRoot(this, docsRoot, "", el);
            v.add(userRoot);
          }
 
          if (userRoot != null) {
            String id;
            for (int i = 0; i < 30; i++) {
              id = userRoot.readConfig("allowed." + i);
              if (id != null) {
                v.add(new DocumentsRoot(this, docsRoot, "/" + id, el));
              }
            }
          }
        }
      }
    }
 
    return (DocumentsRoot[]) v.toArray(new DocumentsRoot[0]);
  }
 
  public void setSelectedId(String selectedId) {
    this.selectedId = selectedId;
  }
 
  public void setSelectedRoot(String selectedRoot) {
    this.selectedRoot = selectedRoot;
  }
 
  public DocumentsRoot getDocumentRootById() {
    for(DocumentsRoot dr : getDocumentRoots()) {
      if(selectedId.equals(dr.getAttribute("id"))) {
        dr.setFileDocumentSelected(selectedRoot);
        return dr;
      }
    }
    return null;
  }
 
  public DocumentsRoot[] getRootsForInsertion() {
    if (selectedInsertion == null) {
      return new DocumentsRoot[0];
    }
    ArrayList v = new ArrayList();
    Element config = getConfiguration();
 
    if (config != null) {
      DocumentsRoot userRoot;
      Iterator it = config.getChildren("root").iterator();
      Element el;
      while (it.hasNext()) {
        userRoot = null;
        el = (Element) it.next();
        if (el.getAttribute("role") == null || constructor.isInRole(el.getAttributeValue("role"))) {
          docsRoot = el.getTextTrim();
          if ("true".equals(el.getAttributeValue("appendUser"))) {
            userRoot = new DocumentsRoot(this, docsRoot, "/" + selectedInsertion, el);
            v.add(userRoot);
          } else {
            userRoot = new DocumentsRoot(this, docsRoot, "", el);
            v.add(userRoot);
          }
        }
      }
    }
 
    return (DocumentsRoot[]) v.toArray(new DocumentsRoot[0]);
  }
 
  public FileDocument[] getInsertionFolders() {
    ArrayList v = new ArrayList();
    for (DocumentsRoot dr : getRootsForInsertion()) {
      fillFolders(v, dr.getFileDocumentRoot(), "true".equals(dr.getAttribute("onlyLeafInsertion")));
    }
    FileDocument fds[] = (FileDocument[]) v.toArray(new FileDocument[0]);
    Arrays.sort(fds);
    return fds;
  }
 
  public Collection getInsertionFoldersWrapped() {
    ArrayList v = new ArrayList();
    for(FileDocument fd : getInsertionFolders()) {
      v.add(new FileDocumentWrapper(fd, false));
    }
    return v;
  }
 
 
  public FileDocument[] getFolders() {
    ArrayList v = new ArrayList();
    for (DocumentsRoot dr : getRootsForInsertion()) {
      fillFolders(v, dr.getFileDocumentRoot(), false);
    }
    return (FileDocument[]) v.toArray(new FileDocument[0]);
  }
 
  private void fillFolders(ArrayList v, FileDocument root, boolean onlyLeafInsert) {
    boolean leaf = true;
    for (FileDocument fd : root.getListFolders()) {
      if (fd.isDirectory()) {
        fillFolders(v, fd, onlyLeafInsert);
        leaf = false;
      }
    }
    if (leaf || !onlyLeafInsert) {
      v.add(root);
    }
  }
  
  public FileDocument[] getNotValidated() {
    ArrayList v = new ArrayList();
    for(DocumentsRoot dr : getRealRoots()) {
      v.addAll(dr.getNotValidated());
    }
    return (FileDocument[]) v.toArray(new FileDocument[0]);
  }
 
  public String getDownloadURL() {
    return ElephantContext.getRootWebPath() + "/Download";
  }
 
  public Localizer getLocalizer() {
    return constructor.getLocalizer();
  }
 
  public Properties getPropertiesFile(String file) {
    Properties tmp = new Properties();
    if (new File(file).exists()) {
      FileInputStream fis;
      try {
        fis = new FileInputStream(file);
        tmp.load(fis);
        fis.close();
      } catch (Exception ex) {
        Logger.getLogger(DocumentsBean.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    return tmp;
  }
 
  public void savePropertiesFile(Properties props, String file) {
    FileOutputStream fos;
    try {
      fos = new FileOutputStream(file);
      props.store(fos, null);
      fos.close();
    } catch (Exception ex) {
      Logger.getLogger(DocumentsBean.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
    }
  }
 
  public void setAttribute(String key, String value) {
    constructor.setSessionAttribute(key, value);
  }
 
  public boolean getCanViewAs() {
    return constructor.isInRole("documents:view-as");
  }
 
  public boolean getCanNew() {
    return constructor.isInRole("documents:new");
  }
 
  public boolean getCanDelete() {
    return constructor.isInRole("documents:delete");
  }
 
  public boolean getCanNewFolder() {
    return constructor.isInRole("documents:new-folder");
  }
 
  public boolean getCanDelFolder() {
    return constructor.isInRole("documents:del-folder");
  }
 
  public boolean getCanEditPermissions() {
    return constructor.isInRole("documents:edit-allowed");
  }
 
  public boolean getCanNewInsertPoint() {
    return constructor.isInRole("documents:new-insertpoint");
  }
 
  public boolean getCanValidate() {
    return constructor.isInRole("documents:validate");
  }
  
  public boolean getCanContact() {
    return constructor.isInRole("contact:list");
  }
  
  public Set getUsers() {
    Set tmp = new TreeSet();
    for (IUser usr : (List<IUser>) constructor.getUser().getUsers()) {
      if (usr.isInRole("documents:list")) {
        tmp.add(new UserWrapper(this, usr));
      }
    }
    return tmp;
  }
 
  public boolean isSelected(IUser user) {
    if (selectedUser == null && constructor.getUser() != null) {
      selectedUser = constructor.getUser().getId();
    }
 
    return selectedUser != null && selectedUser.equals(user.getId());
  }
 
  public String getSelectedUser() {
    return selectedUser;
  }
 
  public Set<DocumentsRoot> getInsertionPointsWrapped() {
    Set tmp = new TreeSet();
    Element config = getConfiguration();
 
    if (config != null) {
      DocumentsRoot userRoot;
      Iterator it = config.getChildren("root").iterator();
      Element el;
      while (it.hasNext()) {
        userRoot = null;
        el = (Element) it.next();
        if (el.getAttribute("role") == null || constructor.isInRole(el.getAttributeValue("role"))) {
          docsRoot = el.getTextTrim();
          userRoot = new DocumentsRoot(this, docsRoot, "", el);
          tmp.addAll(userRoot.getInsertionPointsWrapped());
        }
      }
    }
 
    return tmp;
  }
 
  public boolean isInsertionSelected(FileDocument fd) {
    return selectedInsertion != null && selectedInsertion.equals(fd.getName());
  }
 
  public boolean isFolderSelected(FileDocument fd) {
    return selectedFolder != null && selectedFolder.equals(fd.getAbsolutePath());
  }
 
  public int getMode() {
    return mode;
  }
 
  public String getShowingUsers() {
    return mode == 1 ? "checked" : "";
  }
 
  public String getManagingFiles() {
    return mode == 2 ? "checked" : "";
  }
 
  public String getManagingPermissions() {
    return mode == 3 ? "checked" : "";
  }
 
  public String getAddingInsertionPoint() {
    return mode == 4 ? "checked" : "";
  }
 
  public String getValidating() {
    return mode == 5 ? "checked" : "";
  }
 
  private DocumentsRoot getFromPath(String path) {
    for(DocumentsRoot dr : getRealRoots()) {
      if(path.startsWith(dr.getPath())) {
        return dr;
      }
    }
    return null;
  }
 
  private void processParameters() {
    if (constructor.isInRole("documents:new") && ServletFileUpload.isMultipartContent(constructor.getRequest())) {
      try {
        FileItemFactory factory = new DiskFileItemFactory();
        ServletFileUpload upload = new ServletFileUpload(factory);
        upload.setHeaderEncoding(ElephantContext.getEncoding());
        List items = upload.parseRequest(constructor.getRequest());
        Iterator iter = items.iterator();
        FileItem file = null;
        Map fields = new HashMap();
        while (iter.hasNext()) {
          FileItem item = (FileItem) iter.next();
          if (!item.isFormField()) {
            file = item;
          } else {
            fields.put(item.getFieldName(), item.getString(ElephantContext.getEncoding()));
          }
        }
        if (file != null) {
          try {
            String path = (String) fields.get("path");
            selectedFolder = path;
            String onlyName = file.getName();
            int p = onlyName.lastIndexOf('/');
            if (p == -1) {
              p = onlyName.lastIndexOf('\\');
            }
            new File(path).mkdirs();
            DocumentsRoot dr = getFromPath(path);
            boolean mustValidate = dr != null && "true".equals(dr.getAttribute("validate"));
            String realName = path + "/" + (mustValidate ? "." : "") + onlyName.substring(p + 1);
            File uploadedFile = new File(realName);
            file.write(uploadedFile);
            sendRequiresValidationEmail(dr, uploadedFile);
          } catch (Exception ex) {
            Logger.getLogger(DocumentsBean.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
          }
        }
      } catch (FileUploadException ex) {
        Logger.getLogger(DocumentsBean.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      } catch (UnsupportedEncodingException ex) {
        Logger.getLogger(DocumentsBean.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    } else if (constructor.isInRole("documents:delete") && constructor.getParameter("delfile") != null) {
      File file = new File(constructor.getParameter("path"));
      if (file.exists()) {
        org.amic.util.file.FileUtil.deleteFile(file);
      }
    } else if (constructor.isInRole("documents:new-folder") && constructor.getParameter("newfolder") != null) {
      File file = new File(constructor.getParameter("path"));
      if (file.exists()) {
        file = new File(file.getPath() + "/" + constructor.getParameter("folder").replaceAll("[^\\/a-zA-Z0-9\\-\\_\\.]", "_"));
        file.mkdir();
      }
    } else if (constructor.isInRole("documents:edit-allowed") && constructor.getParameter("saveallowed") != null) {
      IUser user = ContextFactory.getUser(constructor);
      user.impersonate(selectedUser);
      if (user != null) {
        for (DocumentsRoot dr : getRealRoots()) {
          if ("true".equals(dr.getAttribute("appendUser"))) {
            Properties props = dr.getPropertiesFromUser(user);
            for (int i = 0; i < 30; i++) {
              props.remove("allowed." + i);
            }
            int i = 0;
            for (FileDocument fd : dr.getInsertionFolders()) {
              if (constructor.getParameter(fd.getName()) != null) {
                props.put("allowed." + i++, fd.getName());
              }
            }
            dr.savePropertiesToUser(props, user);
            getMessages().addMessage(I_.get("Permissions saved"));
          }
        }
      }
    } else if (constructor.isInRole("documents:new-insertpoint") && constructor.getParameter("addpoint") != null) {
      for (DocumentsRoot dr : getRealRoots()) {
        if ("true".equals(dr.getAttribute("appendUser")) && dr.getPath().equals(constructor.getParameter("selectedRoot"))) {
          dr.addInsertionPoint(constructor.getParameter("idpoint"), constructor.getParameter("namepoint"));
        }
      }
    } else if (constructor.isInRole("documents:validate") && constructor.getParameter("validatefile") != null) {
      File file = new File(constructor.getParameter("path"));
      if (file.exists()) {
        file.renameTo(new File(
                file.getAbsolutePath().substring(0, file.getAbsolutePath().lastIndexOf("/")) +
                "/" +
                file.getName().substring(1)));
      }
    } else {
      if (constructor.getParameter("selectedUser") != null) {
        selectedUser = constructor.getParameter("selectedUser");
      }
      if (constructor.getParameter("selectedInsertion") != null) {
        selectedInsertion = constructor.getParameter("selectedInsertion");
      }
      String m = constructor.getParameter("mode");
      if (m != null) {
        mode = Integer.valueOf(m);
      }
    }
  }
 
  private Element getConfiguration() {
    Element config = null;
    File confFile = new File(ElephantContext.getRealPath(DOCS_CONFIGURATION));
    if (confFile.exists()) {
      SAXBuilder builder = new SAXBuilder();
      Document doc;
      try {
        doc = builder.build(confFile);
        config = doc.getRootElement();
      } catch (IOException ex) {
        Logger.getLogger(DocumentsBean.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      } catch (JDOMException ex) {
        Logger.getLogger(DocumentsBean.class.getName()).log(Level.SEVERE, ElephantContext.logMsg(null), ex);
      }
    }
    return config;
  }
 
  private void sendRequiresValidationEmail(DocumentsRoot dr, File uploadedFile) {
    MailPool mp = (MailPool) ContextFactory.getImplementation(constructor, "IMailPool_Documents");
    mp.setEncoding(ElephantContext.getEncoding());
    mp.addCssFile(ElephantContext.getRealPath("/_internal/css/mail.css"));
    String subject = I_.get("{file} requires validation").replaceAll("\\{file\\}", uploadedFile.getName());
    Set<MailUser> emails = new HashSet<MailUser>();
    emails.add(new MailUser(constructor, dr.getAttribute("owner"), "#user", subject, ""));
    for(MailUser mc : emails) {
      mp.addToPool(null, mc.getEmail(), null, subject, mc.getMessage(""), "text/html");
    }
    mp.sendPool();
  }
}