FileSystem durch Commons io ersetzt

Ulrich

2017-03-01 5bfd3435869632cf8796f116bfef12bd0d6345e7

 src/java/de/uhilger/filecms/api/FileMgr.java

@@ -1,147 +1,373 @@
/*
    Dateiverwaltung - File management in your browser
    Copyright (C) 2017 Ulrich Hilger, http://uhilger.de

    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 de.uhilger.filecms.api;

import de.uhilger.filesystem.FileRef;
import de.uhilger.transit.web.RequestKontext;
import de.uhilger.transit.web.WebKontext;
import de.uhilger.filecms.data.FileRef;
import de.uhilger.filecms.web.Initialiser;
//import de.uhilger.filesystem.FileRef;
//import de.uhilger.filesystem.FileSystem;
//import de.uhilger.filesystem.LocalFileSystem;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.security.Principal;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.io.FileUtils;

/**
 *
 * @author ulrich
 */
public class FileMgr implements WebKontext, RequestKontext {
public class FileMgr extends Api {
  private static final Logger logger = Logger.getLogger(FileMgr.class.getName());
  
  public static final String FILE_BASE = "fileBase";
  public static final String PUB_DIR_PATH = "www/";
  public static final String HOME_DIR_PATH = "home/";
  public static final String PUB_DIR_NAME = "Oeffentlich";
  public static final String HOME_DIR_NAME = "Persoenlicher Ordner";
  
  private ServletContext ctx;
  private HttpServletRequest req;
  public static final int OP_COPY = 1;
  public static final int OP_MOVE = 2;
  
  public String hallo() {
    return "Hallo Welt!";
  }
  
  // http://localhost:8097/file-cms/rpc/de.uhilger.filecms.api.FileMgr/getBase/JSONNICE
  public FileRef getBase() {
    FileRef ref = null;
    //String fileBase = getServletContext().getInitParameter(FILE_BASE);
    // -Dfilecms.base=/pfad/zu/daten
    //String fileBase = System.getProperty("filecms.base");
    //File file = new File(fileBase);
    //logger.info(file.getAbsolutePath());
    //logger.info(getWebappsDir().getAbsolutePath());
    
    /* 
        file = new File("."); liefert 
        /home/ulrich/dev/lib/java/tomcat/tomcat2-8.5.9/bin/.
    
        ..auf der WebBox aber
        /home/ulrich/srv/wbx_probe/.
        ..weil das Startskript dort liegt
    
        der Tomcat der WebBox ist unter
        sys/jrs/tomcat/bin
    
        also z.B.
        /home/ulrich/srv/wbx_probe/sys/jrs/tomcat/bin

        das Datenverzeichnis ist z.B. auf
        /home/ulrich/srv/wbx_probe/daten
    
        dann ist das Datenverzeichnis unter
        ../../../daten
    
        Der Ausdruck file = new File("."); liefert stets den 
        Ort von dem aus der Java-Prozess gestartet wurde.
    
        Die unten folgende Bestimmung des Datenverzeichnisses 
        ist beschraenkt auf das Datenverzeichnis der WebBox, 
        entweder relativ zum Startskript der WebBox oder 
        dem Startskript von Tomcat, wie es aus Netbeans heraus 
        waehrend der Entwicklung genutzt wird.
    
        Besser ware vielleicht eine Bestimmung ueber einen 
        Systemparameter -Dfilecms.base=... wie weiter oben 
        auskommentiert. Damit liesse sich das file-cms auch 
        ohne WebBox einsetzen. Allerdings muss dann das 
        Datenverzeichnis im Start-Skript gebildet werden, 
        also ausserhalb von Java, wenn es dynamisch aus 
        einem Pfad relativ zum Start-Skript erzeugt werden 
        soll.
    */
    
    File file = new File(".");
    String path = file.getAbsolutePath();
    path = path.substring(0, path.length() - 1);
    file = new File(path);
    if(path.endsWith("bin")) {
      file = file.getParentFile().getParentFile().getParentFile();
  public List<FileRef> list(String relPath) {
    List<FileRef> files = new ArrayList();
    if(relPath.length() == 0) {
      FileRef namedPublicFolder = new FileRef(PUB_DIR_NAME, true);
      logger.finer(namedPublicFolder.getAbsolutePath());
      FileRef namedHomeFolder = new FileRef(HOME_DIR_NAME, true);
      logger.finer(namedHomeFolder.getAbsolutePath());
      files = new ArrayList();
      files.add(namedHomeFolder);
      files.add(namedPublicFolder);
    } else {
      
    }
    file = new File(file, "daten/");
    ref = new FileRef(file.getAbsolutePath(), file.isDirectory());
    return ref;
      String path = getTargetDir(relPath).getAbsolutePath();
      logger.fine("listing path: " + path);
      //LocalFileSystem fs = new LocalFileSystem();
      //logger.fine("listing " + getTargetDir(relPath).getAbsolutePath());
      File dir = new File(path);
      if(dir.exists()) {
        File[] fileArray = dir.listFiles();

        //FileRef[] fileRefs = fs.list(new FileRef(getTargetDir(relPath).getAbsolutePath(), true));
        for(int i = 0; i < fileArray.length; i++) {
          logger.fine(fileArray[i].toURI().toString());
          String fname = fileArray[i].toURI().toString().replace("file:/", "");
          if(fileArray[i].isDirectory()) {
            fname = fname.substring(0, fname.length() - 1);
          }
          logger.fine(fname);
          files.add(new FileRef(fname, fileArray[i].isDirectory()));
        }
      }
    }    
    return files;
  }
  
  public FileRef newFolder(String relPath, String folderName) {
    logger.finer(relPath);
    String targetPath = null;
    if(relPath.startsWith(PUB_DIR_NAME)) {
      targetPath = PUB_DIR_PATH + getUserName() + "/" + relPath.substring(PUB_DIR_NAME.length()) + "/" + folderName;
    } else if(relPath.startsWith(HOME_DIR_NAME)) {
      targetPath = HOME_DIR_PATH + getUserName() + "/" + relPath.substring(HOME_DIR_NAME.length()) + "/" + folderName;
    } else {
      // kann eigentlich nicht sein..
    }
    logger.finer(targetPath);
    File targetDir = new File(getBase().getAbsolutePath(), targetPath);
    targetDir.mkdirs();
    return new FileRef(targetDir.getAbsolutePath(), true);
  }
  
  public String getCode(String relPath, String fileName) {
    String code = null;
    
    Object p = getRequest().getUserPrincipal();
    if(p instanceof Principal) {
      FileReader reader = null;
      try {
        File targetFile = new File(getTargetDir(relPath), fileName);
        reader = new FileReader(targetFile);
        StringBuffer buf = new StringBuffer();
        char[] readBuffer = new char[1024];
        int charsRead = reader.read(readBuffer);
        while(charsRead > -1) {
          buf.append(readBuffer, 0, charsRead);
          charsRead = reader.read(readBuffer);
        }
        code = buf.toString();
      } catch (FileNotFoundException ex) {
        Logger.getLogger(FileMgr.class.getName()).log(Level.SEVERE, null, ex);
      } catch (IOException ex) {
        Logger.getLogger(FileMgr.class.getName()).log(Level.SEVERE, null, ex);
      } finally {
        try {
          reader.close();
        } catch (IOException ex) {
          Logger.getLogger(FileMgr.class.getName()).log(Level.SEVERE, null, ex);
        }
      }
      
    }    
    
    return code;
  }
  
  public String deleteFiles(String relPath, List fileNames) {
    String result = null;
    try {
      logger.fine(fileNames.toString());
      File targetDir = getTargetDir(relPath);
      for(int i=0; i < fileNames.size(); i++) {
        Object o = fileNames.get(i);
        if(o instanceof ArrayList) {
          ArrayList al = (ArrayList) o;
          logger.fine(al.get(0).toString());
          File targetFile = new File(targetDir, al.get(0).toString());
          logger.fine(targetFile.getAbsolutePath());
          if(targetFile.isDirectory()) {
            FileUtils.deleteDirectory(targetFile);
          } else {
            targetFile.delete();
          }
        }
      }
      result = "deleted";
    } catch (Throwable ex) {
      logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
    }
    return result;
  }
  
  public String copyFiles(String fromPath, String toPath, List fileNames) {
    String result = null;
    try {
      File srcDir = getTargetDir(fromPath);
      File targetDir = getTargetDir(toPath);
      Iterator i = fileNames.iterator();
      while(i.hasNext()) {
        Object o = i.next();
        if (o instanceof ArrayList) {
          ArrayList al = (ArrayList) o;
          File srcFile = new File(srcDir, al.get(0).toString());
          if(srcFile.isDirectory()) {
            logger.fine("copy dir " + srcFile.getAbsolutePath() + " to dir " + targetDir.getAbsolutePath());
            FileUtils.copyDirectoryToDirectory(srcFile, targetDir);
          } else {
            logger.fine("copy srcFile " + srcFile.getAbsolutePath() + " to dir " + targetDir.getAbsolutePath());
            FileUtils.copyFileToDirectory(srcFile, targetDir);
          }
        }
      }
    } catch (IOException ex) {
      logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
    }
    return result;
  }
  
  public String moveFiles(String fromPath, String toPath, List fileNames) {
    String result = null;
    try {
      File srcDir = getTargetDir(fromPath);
      File targetDir = getTargetDir(toPath);
      Iterator i = fileNames.iterator();
      while(i.hasNext()) {
        Object o = i.next();
        if (o instanceof ArrayList) {
          ArrayList al = (ArrayList) o;
          File srcFile = new File(srcDir, al.get(0).toString());
          if(srcFile.isDirectory()) {
            FileUtils.moveDirectoryToDirectory(srcFile, targetDir, false);
          } else {
            FileUtils.moveFileToDirectory(srcFile, targetDir, false);
          }
        }
      }
    } catch (IOException ex) {
      logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
    }
    return result;
    //return copyOrMoveFiles(fromPath, toPath, fileNames, OP_MOVE);
  }
  
  /**
   * Dateien kopieren
   * 
   * @param fromPath der relative Pfad, aus dem die Dateien stammen, die kopiert werden sollen
   * @param toPath der relative Pfad, an den die Dateien kopiert werden sollen
   * @param fileNames  Liste mit Namen der Dateien, die kopiert werden sollen
   * @param operation OP_COPY oder OP_MOVE
   * @return null bei Fehler oder Quittungstext, wenn erfolgreich
   */
  /*
  private String copyOrMoveFiles(String fromPath, String toPath, List fileNames, int operation) {
    String result = null;
    try {
      FileRef[] files = new FileRef[fileNames.size()];
      logger.fine(fileNames.toString());
      File srcDir = getTargetDir(fromPath);
      for(int i=0; i < fileNames.size(); i++) {
        Object o = fileNames.get(i);
        if(o instanceof ArrayList) {
          ArrayList al = (ArrayList) o;
          logger.fine(al.get(0).toString());
          File srcFile = new File(srcDir, al.get(0).toString());
          logger.fine(srcFile.getAbsolutePath());
          files[i] = new FileRef(srcFile.getAbsolutePath(), srcFile.isDirectory());
        }
      }
      File targetDir = getTargetDir(toPath);
      FileSystem fs = new LocalFileSystem();
      switch(operation) {
        case OP_COPY:
          fs.copy(files, new FileRef(targetDir.getAbsolutePath(), true));
          FileUtils.copy
          break;
        case OP_MOVE:
          fs.move(files, new FileRef(targetDir.getAbsolutePath(), true));
          break;
      }
      result = "kopiert";
    } catch (Throwable ex) {
      logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
    }
    return result;
  }
  */
  
  public FileRef saveTextFile(String relPath, String fileName, String contents) {
    FileRef savedFile = null;
    try {
      FileRef datenRef = getBase();
      File daten = new File(datenRef.getAbsolutePath());
      //File daten = new File(datenRef.getAbsolutePath());
      Object p = getRequest().getUserPrincipal();
      if(p instanceof Principal) {
        File userDir = new File(daten, "www/" + ((Principal) p).getName());
        File saveDir = new File(userDir, relPath);
        File targetFile = new File(saveDir, fileName);
        if(!targetFile.exists()) {
        File targetFile = new File(getTargetDir(relPath), fileName);
        if(targetFile.exists()) {
          /*
            muss delete() sein?
            pruefen: ueberschreibt der FileWriter den alteen Inhalt oder 
            entsteht eine unerwuenschte Mischung aus altem und neuem 
            Inhalt?
          */
          targetFile.delete();
        } else {
          targetFile.getParentFile().mkdirs();
          targetFile.createNewFile();
          FileWriter w = new FileWriter(targetFile);
          w.write(contents);
          w.flush();
          w.close();
          savedFile = new FileRef(targetFile.getAbsolutePath(), targetFile.isDirectory(), targetFile.isHidden(), targetFile.lastModified(), targetFile.length());
        }
        targetFile.createNewFile();
        FileWriter w = new FileWriter(targetFile);
        w.write(contents);
        w.flush();
        w.close();
        savedFile = new FileRef(
                targetFile.getAbsolutePath(), 
                targetFile.isDirectory(), 
                targetFile.isHidden(), 
                targetFile.lastModified(), 
                targetFile.length());
      }
    } catch (IOException ex) {
      logger.log(Level.SEVERE, null, ex);
    }
    return savedFile;
  }
    
  /* ---- Hilfsfunktionen ---- */
  
  private File getTargetDir(String relPath) {
    logger.fine(relPath);
    String targetPath = null;
    if(relPath.startsWith(PUB_DIR_NAME)) {
      targetPath = PUB_DIR_PATH + getUserName() + relPath.substring(PUB_DIR_NAME.length());
    } else if(relPath.startsWith(HOME_DIR_NAME)) {
      targetPath = HOME_DIR_PATH + getUserName() + relPath.substring(HOME_DIR_NAME.length());
    } else {
      // kann eigentlich nicht sein..
    }
    logger.fine(targetPath);
    File targetDir = new File(getBase().getAbsolutePath(), targetPath);
    return targetDir;
  }
  
  private FileRef getBase() {
    FileRef base = null;
    Object o = getServletContext().getAttribute(Initialiser.FILE_BASE);
    if(o instanceof String) {
      String baseStr = (String) o;
      logger.fine(baseStr);
      File file = new File(baseStr);
      base = new FileRef(file.getAbsolutePath(), file.isDirectory());
    }
    return base;
  }
  
  private String getUserName() {
    String userName = null;
    Object p = getRequest().getUserPrincipal();
    if(p instanceof Principal) {
      userName = ((Principal) p).getName();
    }
    return userName;
  }
  
  /*
  private File getWebappsDir() {
    File cfile = new File(this.getClass().getResource(this.getClass().getSimpleName() + ".class").getFile());
    File cfile = new File(this.getClass().getResource(
            this.getClass().getSimpleName() + ".class").getFile());
    String path = cfile.getAbsolutePath();
    return new File(path.substring(0, path.indexOf(req.getContextPath())));
    return new File(path.substring(0, path.indexOf(getRequest().getContextPath())));
  }

  @Override
  public ServletContext getServletContext() {
    return ctx;
  }

  @Override
  public void setServletContext(ServletContext servletContext) {
    this.ctx = servletContext;
  }

  @Override
  public HttpServletRequest getRequest() {
    return req;
  }

  @Override
  public void setRequest(HttpServletRequest r) {
    this.req = r;
  }

  
  */
    
}


/*
  https://stackoverflow.com/questions/300559/move-copy-file-operations-in-java



Try to use org.apache.commons.io.FileUtils (General file manipulation utilities). Facilities are provided in the following methods:

    (1) FileUtils.moveDirectory(File srcDir, File destDir) => Moves a directory.

    (2) FileUtils.moveDirectoryToDirectory(File src, File destDir, boolean createDestDir) => Moves a directory to another directory.

    (3) FileUtils.moveFile(File srcFile, File destFile) => Moves a file.

    (4) FileUtils.moveFileToDirectory(File srcFile, File destDir, boolean createDestDir) => Moves a file to a directory.

    (5) FileUtils.moveToDirectory(File src, File destDir, boolean createDestDir) => Moves a file or directory to the destination directory.

It's simple, easy and fast.
  

  https://commons.apache.org/proper/commons-io/javadocs/api-2.5/org/apache/commons/io/FileUtils.html

*/