Directory.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.wd.files;
 
import java.io.File;
import java.text.ParseException;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.pivot.collections.ArrayList;
import org.apache.pivot.collections.Collection;
import org.apache.pivot.serialization.BinarySerializer;
import org.apache.pivot.web.GetQuery;
import org.apache.pivot.web.QueryException;
import org.jdom.Element;
import org.turro.pivot.dialog.ProgressSheet;
import org.turro.wd.entities.ServerFile;
 
public class Directory implements Comparable<Directory> {
 
  private Directory parent;
  private String serverPath, name;
  private DirectorySet dirs = new DirectorySet();
  private WorkFileSet files = new WorkFileSet();
  private int nUpdates, nCommits, nFiles;
 
  public DirectorySet getDirs() {
    return dirs;
  }
 
  public void setDirs(DirectorySet dirs) {
    this.dirs = dirs;
  }
 
  public WorkFileSet getFiles() {
    return files;
  }
 
  public void setFiles(WorkFileSet files) {
    this.files = files;
  }
 
  public String getName() {
    return name;
  }
 
  public void setName(String name) {
    this.name = name;
  }
 
  public Directory getParent() {
    return parent;
  }
 
  public void setParent(Directory parent) {
    this.parent = parent;
  }
 
  public String getAbsolutePath() {
    String ap = null;
    Directory current = this;
    while (current != null) {
      if (current.getPath() != null) {
        ap = current.getPath() + (ap == null ? "" : "/" + ap);
      }
      current = current.getParent();
    }
    return ap;
  }
 
  public String getPath() {
    if (getServerPath() != null) {
      return getServerPath();
    } else {
      return getName();
    }
  }
 
  public String getServerPath() {
    return serverPath;
  }
 
  public void setServerPath(String serverPath) {
    this.serverPath = serverPath;
  }
 
  public String getSystemName() {
    return getName()
            .replaceAll("\\|", "-")
            .replaceAll("\\<", "-")
            .replaceAll("\\>", "-")
            .replaceAll("\\:", "-")
            .replaceAll("\"", "'")
            .replaceAll("\\\\", "-")
            .replaceAll("\\/", "-")
            .replaceAll("\\*", "-")
            .replaceAll("\\&", "i")
            .replaceAll("\\%", "-")
            .replaceAll("\\?", "-");
  }
 
  public String getSystemPath() {
    String sp = null;
    Directory current = this;
    while (current != null) {
      if (current.getSystemName() != null) {
        sp = current.getSystemName() + (sp == null ? "" : "/" + sp);
        current = current.getParent();
      }
    }
    return sp;
  }
 
  public File getSystemFile() {
    String sp = getSystemPath();
    if (sp != null) {
      return new File(sp);
    }
    return null;
  }
 
  public String getHost() {
    Directory current = this;
    while (!(current instanceof WorkingDirectory)) {
      current = current.getParent();
    }
    return ((WorkingDirectory) current).getBbHost();
  }
 
  public Integer getPort() {
    Directory current = this;
    while (!(current instanceof WorkingDirectory)) {
      current = current.getParent();
    }
    String port = ((WorkingDirectory) current).getBbPort();
    return port == null ? 80 : new Integer(port);
  }
 
  public String getContext() {
    Directory current = this;
    while (!(current instanceof WorkingDirectory)) {
      current = current.getParent();
    }
    return ((WorkingDirectory) current).getBbContext();
  }
 
  public String getUser() {
    Directory current = this;
    while (!(current instanceof WorkingDirectory)) {
      current = current.getParent();
    }
    return ((WorkingDirectory) current).getBbUser();
  }
 
  public boolean isRoot() {
    return parent instanceof WorkingDirectory;
  }
 
  public boolean isWorkingDirectory() {
    return this instanceof WorkingDirectory;
  }
 
  public boolean isExistsOnServer() {
    return !isWorkingDirectory() && getServerPath() != null;
  }
 
  public boolean isUpdatable() {
    return !isWorkingDirectory()
            && ((isRoot() && getServerPath() != null)
            || !isRoot() && parent.isUpdatable());
  }
 
  public Directory addDirectory(String name) {
    Directory wdir = new Directory();
    wdir.setParent(this);
    wdir.setName(name == null ? "wdtmp" : name);
    dirs.add(wdir);
    return wdir;
  }
 
  public WorkFile addFile(String name) {
    WorkFile wfile = new WorkFile();
    wfile.setParent(this);
    wfile.setName(name == null ? "wdtmp" : name);
    files.add(wfile);
    return wfile;
  }
 
  public int getnCommits() {
    return nCommits;
  }
 
  public int getnFiles() {
    return nFiles;
  }
 
  public int getnUpdates() {
    return nUpdates;
  }
 
  protected void countFiles() throws ParseException {
    nUpdates = nCommits = nFiles = 0;
    for(Directory d : getDirs()) {
      d.countFiles();
      nUpdates += d.nUpdates;
      nCommits += d.nCommits;
      nFiles += d.nFiles;
    }
    for(WorkFile wf : getFiles()) {
      nFiles++;
      if(wf.isDownloadable()) {
        nUpdates++;
      } else if(wf.isUploadable()) {
        nCommits++;
      }
    }
  }
 
  protected void readXML(Element root) throws ParseException {
    if (root.getAttributeValue("name") != null) {
      setName(root.getAttributeValue("name"));
    }
    if (root.getAttributeValue("serverPath") != null) {
      setServerPath(decryptString(root.getAttributeValue("serverPath")));
      return;
    }
    for (Element el : (List<Element>) root.getChildren("wdir")) {
      Directory wdir = addDirectory(null);
      wdir.readXML(el);
    }
    for (Element el : (List<Element>) root.getChildren("wfile")) {
      WorkFile wfile = addFile(null);
      wfile.readXML(el);
    }
  }
 
  protected void writeXML(Element root) {
    Element el;
    if (!isWorkingDirectory()) {
      el = new Element("wdir");
      el.setAttribute("name", getName());
      if (getServerPath() != null) {
        el.setAttribute("serverPath", encryptString(getServerPath()));
      }
      root.addContent(el);
      if (getServerPath() != null) return;
    } else {
      el = root;
    }
    for (Directory d : dirs) {
      d.writeXML(el);
    }
    for (WorkFile f : files) {
      f.writeXML(el);
    }
  }
 
  protected boolean checkExisting() {
    if(!(isRoot() || isWorkingDirectory())) return false;
    File dir = getSystemFile();
    ProgressSheet.nextProgress(dir.getName());
    if (dir != null && dir.exists()) {
      Iterator<Directory> itd = getDirs().iterator();
      while (itd.hasNext()) {
        if (!itd.next().checkExisting()) {
          itd.remove();
        }
      }
//      Iterator<WorkFile> itwf = getFiles().iterator();
//      while (itwf.hasNext()) {
//        if (!itwf.next().checkExisting()) {
//          itwf.remove();
//        }
//      }
      return true;
    } else {
      return false;
    }
  }
 
  protected void loadSystemFiles() {
    File dir = getSystemFile();
    for (File file : dir.listFiles()) {
      if(file.getName().startsWith(".") ||
              file.getName().endsWith("~") ||
              file.isHidden()) {
        continue;
      }
      ProgressSheet.nextProgress(file.getName());
      if (file.isDirectory()) {
        Directory d = getDirs().getDir(file.getName());
        if (d == null) {
          d = addDirectory(file.getName());
        }
        d.loadSystemFiles();
      } else if (file.isFile()) {
        WorkFile wf = getFiles().getFile(file.getName());
        if (wf == null) {
          wf = addFile(file.getName());
        }
        wf.setFile(file);
      }
    }
  }
 
  protected void loadServerFiles() {
    for (Directory d : getDirs()) {
      d.loadServerFiles();
    }
    for (String folder : doQueryFolders()) {
      ProgressSheet.nextProgress(folder);
      if (!getDirs().containsDir(folder)) {
        Directory nd = addDirectory(folder);
        nd.loadServerFiles();
      }
    }
    for (ServerFile sf : doQueryFiles()) {
      WorkFile wf = getFiles().getFile(sf.getFileName());
      if (wf == null) {
        wf = addFile(sf.getFileName());
      }
      ProgressSheet.nextProgress(sf.getFileName());
      wf.setDownModification(sf.getModification());
      wf.setServerOwner(sf.getOwner());
      wf.setServerSize(sf.getFileSize());
      wf.setServerLocked(sf.isLocked());
      wf.setServerLocker(sf.getLocker());
    }
  }
 
  public int compareTo(Directory o) {
    if (getName() == null || o.getName() == null) {
      return 0;
    }
    return getName().compareTo(o.getName());
  }
 
  public Collection<String> doQueryFolders() {
    if (isUpdatable()) {
      try {
        GetQuery getQuery = new GetQuery(
                getHost(), getPort(),
                getContext() + "/pservice/queryFolders", false);
        getQuery.getParameters().put("user", getUser());
        getQuery.getParameters().put("path", getAbsolutePath());
        getQuery.setSerializer(new BinarySerializer());
        return (Collection<String>) getQuery.execute();
      } catch (QueryException ex) {
        Logger.getLogger(Directory.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
    return new ArrayList<String>();
  }
 
  public Collection<ServerFile> doQueryFiles() {
    if (isUpdatable()) {
      try {
        GetQuery getQuery = new GetQuery(
                getHost(), getPort(),
                getContext() + "/pservice/queryFiles", false);
        getQuery.getParameters().put("user", getUser());
        getQuery.getParameters().put("path", getAbsolutePath());
        getQuery.setSerializer(new BinarySerializer());
        return (Collection<ServerFile>) getQuery.execute();
      } catch (QueryException ex) {
        Logger.getLogger(Directory.class.getName()).log(Level.SEVERE, null, ex);
      }
    }
    return new ArrayList<ServerFile>();
  }
  
  private static String encryptString(String str) {
    StringBuilder sb = new StringBuilder();
    for(byte b : str.getBytes()) {
      sb.append(String.format("%03d", b));
    }
    return sb.toString();
  }
 
  private static String decryptString(String str) {
    byte[] b = new byte[str.length() / 3];
    for(int i = 0; i < str.length(); i+=3) {
      b[i / 3] = new Byte(str.substring(i, i+3));
    }
    return new String(b);
  }
 
}