Dateiverwaltung für die WebBox
ulrich
2020-03-01 631a8812e9bf9d08944bc18d972cb6134337facf
commit | author | age
8931b7 1 /*
U 2     Dateiverwaltung - File management in your browser
3     Copyright (C) 2017 Ulrich Hilger, http://uhilger.de
4
5     This program is free software: you can redistribute it and/or modify
6     it under the terms of the GNU Affero General Public License as
7     published by the Free Software Foundation, either version 3 of the
8     License, or (at your option) any later version.
9
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU Affero General Public License for more details.
14
15     You should have received a copy of the GNU Affero General Public License
16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
17 */
18
c7c502 19 package de.uhilger.filecms.api;
U 20
6e70be 21 import de.uhilger.filecms.data.FileRef;
d14d78 22 import de.uhilger.filecms.pub.AbstractComparator;
U 23 import de.uhilger.filecms.pub.FileNameComparator;
332c05 24 import de.uhilger.filecms.pub.ImgFileFilter;
bb9f8c 25 import de.uhilger.wbx.Bild;
e639c2 26 import de.uhilger.wbx.WbxUtils;
26115e 27 import static de.uhilger.wbx.WbxUtils.EMPTY_STRING;
U 28 import static de.uhilger.wbx.WbxUtils.WBX_FILE_BASE;
4e2a82 29 import de.uhilger.wbx.data.Inhalt;
332c05 30 import de.uhilger.wbx.web.TNServlet;
8e51b7 31 import java.io.File;
332c05 32 import java.io.FileFilter;
af9930 33 import java.io.FileInputStream;
3ad4db 34 import java.io.FileNotFoundException;
6bd2c1 35 import java.io.FileOutputStream;
3ad4db 36 import java.io.FileReader;
e5ff42 37 import java.io.FileWriter;
U 38 import java.io.IOException;
6bd2c1 39 import java.io.InputStream;
fab80c 40 import java.io.Reader;
e5ff42 41 import java.security.Principal;
7342b1 42 import java.util.ArrayList;
d14d78 43 import java.util.Arrays;
26115e 44 import java.util.Collections;
U 45 import java.util.Comparator;
6bd2c1 46 import java.util.Enumeration;
5bfd34 47 import java.util.Iterator;
7342b1 48 import java.util.List;
e5ff42 49 import java.util.logging.Level;
8e51b7 50 import java.util.logging.Logger;
af9930 51 import java.util.zip.Adler32;
U 52 import java.util.zip.CheckedOutputStream;
6bd2c1 53 import java.util.zip.ZipEntry;
U 54 import java.util.zip.ZipFile;
af9930 55 import java.util.zip.ZipOutputStream;
4e2a82 56 import javax.servlet.http.HttpServletRequest;
bb9f8c 57 import net.coobird.thumbnailator.Thumbnails;
5bfd34 58 import org.apache.commons.io.FileUtils;
e18175 59 import org.apache.commons.io.filefilter.WildcardFileFilter;
c7c502 60
U 61 /**
fafe1b 62  * Methoden zur Verwaltung von Dateien
c7c502 63  */
8931b7 64 public class FileMgr extends Api {
8e51b7 65   private static final Logger logger = Logger.getLogger(FileMgr.class.getName());
931544 66     
9e2964 67   public static final int OP_COPY = 1;
U 68   public static final int OP_MOVE = 2;
931544 69   
U 70   public static final String DOT = ".";
9e2964 71   
ea7193 72   public String hallo() {
U 73     return "Hallo Welt!";
74   }
75   
1f550a 76   /**
U 77    * Inhalte der WebBox listen. Hier wird nur der relative Pfad 
78    * ausgehend von www oder home ausgegeben sowie zudem ausgehend 
79    * von $daten und $basis, sofern der Benutzer die Rolle wbxAdmin hat.
80    * 
81    * Andere Inhalte werden nicht ausgegeben.
82    * 
83    * @param relPath
84    * @return 
85    */
7342b1 86   public List<FileRef> list(String relPath) {
d14d78 87     return listInt(relPath, "name", AbstractComparator.ORDER_ASC);
U 88   }
89   
90   public List<FileRef> listOrdered(String relPath, String orderBy, String order) {
91     return listInt(relPath, orderBy, order);
92   }
93   
94   /**
95    * Inhalte der WebBox listen. Hier wird nur der relative Pfad 
96    * ausgehend von www oder home ausgegeben sowie zudem ausgehend 
97    * von $daten und $basis, sofern der Benutzer die Rolle wbxAdmin hat.
98    * 
99    * Andere Inhalte werden nicht ausgegeben.
100    * 
101    * @param relPath
102    * @param orderBy 'name'
103    * @param order AbstractComparator.ORDER_ASC oder AbstractComparator.ORDER_DESC
104    * @return 
105    */
106   private List<FileRef> listInt(String relPath, String orderBy, String order) {
f7d8bf 107     Bild bild = new Bild();
5dfab6 108     List<FileRef> files = new ArrayList();
ac72fe 109     if (!relPath.startsWith(".") && !relPath.contains("WEB-INF") && !relPath.contains("META-INF")) {
3d0c6d 110       if (relPath.length() == 0) {
U 111         FileRef namedPublicFolder = new FileRef(PUB_DIR_NAME, true);
112         logger.finer(namedPublicFolder.getAbsolutePath());
113         FileRef namedHomeFolder = new FileRef(HOME_DIR_NAME, true);
114         logger.finer(namedHomeFolder.getAbsolutePath());
115         FileRef namedDavFolder = new FileRef(DAV_DIR_NAME, true);
116         logger.finer(namedDavFolder.getAbsolutePath());
117         files = new ArrayList();
118         files.add(namedHomeFolder);
119         files.add(namedPublicFolder);
120         files.add(namedDavFolder);
121         if (getRequest().isUserInRole(WBX_ADMIN_ROLE)) {
122           FileRef namedBaseFolder = new FileRef(WBX_BASE, true);
123           FileRef namedDataFolder = new FileRef(WBX_DATA, true);
124           files.add(namedBaseFolder);
125           files.add(namedDataFolder);
d14d78 126         }
3d0c6d 127       } else {
U 128         String path = getTargetDir(relPath).getAbsolutePath();
129         logger.fine("listing path: " + path);
130         File dir = new File(path);
131         if (dir.exists()) {
332c05 132           File[] fileArray = dir.listFiles(new ImgFileFilter());
3d0c6d 133           if (orderBy != null && orderBy.equalsIgnoreCase("name")) {
U 134             Arrays.sort(fileArray, new FileNameComparator(order));
135           } else {
136             Arrays.sort(fileArray, new FileNameComparator(AbstractComparator.ORDER_ASC));
5bfd34 137           }
3d0c6d 138           for (int i = 0; i < fileArray.length; i++) {
U 139             logger.fine(fileArray[i].toURI().toString());
140             String fname = fileArray[i].toURI().toString().replace("file:/", "");
141             if (fileArray[i].isDirectory()) {
142               fname = fname.substring(0, fname.length() - 1);
143             }
144             logger.fine(fname);
ac72fe 145             if(!fname.contains("WEB-INF") && !fname.contains("META-INF")) {
c5eaaa 146               long fLen = fileArray[i].length();
U 147               long lastMod = fileArray[i].lastModified();
148               FileRef ref = new FileRef(fname, fileArray[i].isDirectory(), fileArray[i].isHidden(), lastMod, fLen);
ac72fe 149               ref.setMimetype(bild.getMimeType(fileArray[i]));
U 150               files.add(ref);
151             }
3d0c6d 152           }
5bfd34 153         }
5dfab6 154       }
3d0c6d 155     }
7342b1 156     return files;
2121cc 157   }
4e2a82 158
26115e 159   public List<Inhalt> collect(String relativePath, int maxTiefe, int maxAnzahl, int len) {
U 160     
4e2a82 161     WbxUtils wu = new WbxUtils();
U 162     HttpServletRequest req = getRequest();
163     String requestUrl = req.getRequestURL().toString();
164     String contextPath = req.getContextPath();
26115e 165     return wu.collectFiles(requestUrl, contextPath, relativePath, maxTiefe, maxAnzahl, len);
4e2a82 166   }
d14d78 167   
c509a0 168   public FileRef newFolder(String relPath, String folderName) {
eb2a2d 169     if (!relPath.startsWith(".")) {
U 170       logger.finer(relPath);
171       String targetPath = null;
172       if(relPath.startsWith(PUB_DIR_NAME)) {
173         targetPath = PUB_DIR_PATH + getUserName() + "/" + relPath.substring(PUB_DIR_NAME.length()) + "/" + folderName;
174       } else if(relPath.startsWith(HOME_DIR_NAME)) {
175         targetPath = HOME_DIR_PATH + getUserName() + "/" + relPath.substring(HOME_DIR_NAME.length()) + "/" + folderName;
176       } else {
177         // kann eigentlich nicht sein..
178       }
179       logger.finer(targetPath);
180       File targetDir = new File(getBase().getAbsolutePath(), targetPath);
181       targetDir.mkdirs();
182       return new FileRef(targetDir.getAbsolutePath(), true);
c509a0 183     } else {
eb2a2d 184       return null;
c509a0 185     }
5dfab6 186   }
U 187   
3ad4db 188   public String getCode(String relPath, String fileName) {
U 189     String code = null;
eb2a2d 190     if (!relPath.startsWith(".")) {
U 191       Object p = getRequest().getUserPrincipal();
192       if (p instanceof Principal) {
193         Reader reader = null;
3ad4db 194         try {
eb2a2d 195           File targetFile = new File(getTargetDir(relPath), fileName);
U 196
197           //reader = new InputStreamReader(new FileInputStream(targetFile), "UTF8");
198           reader = new FileReader(targetFile);
199           StringBuffer buf = new StringBuffer();
200           char[] readBuffer = new char[1024];
201           int charsRead = reader.read(readBuffer);
202           while (charsRead > -1) {
203             buf.append(readBuffer, 0, charsRead);
204             charsRead = reader.read(readBuffer);
205           }
206           code = buf.toString();
207         } catch (FileNotFoundException ex) {
208           Logger.getLogger(FileMgr.class.getName()).log(Level.SEVERE, null, ex);
3ad4db 209         } catch (IOException ex) {
U 210           Logger.getLogger(FileMgr.class.getName()).log(Level.SEVERE, null, ex);
eb2a2d 211         } finally {
U 212           try {
213             reader.close();
214           } catch (IOException ex) {
215             Logger.getLogger(FileMgr.class.getName()).log(Level.SEVERE, null, ex);
216           }
3ad4db 217         }
eb2a2d 218
3ad4db 219       }
eb2a2d 220     }
3ad4db 221     return code;
U 222   }
223   
663ee9 224   public String renameFile(String relPath, String fname, String newName) {
eb2a2d 225     if (!relPath.startsWith(".")) {
U 226       File targetDir = getTargetDir(relPath);
227       File file = new File(targetDir, fname);
931544 228       if(fname.endsWith(TNServlet.JPEG) || fname.endsWith(TNServlet.JPG) || fname.endsWith(TNServlet.PNG)) {
U 229         renameImgFiles(targetDir, file, newName);  
230       } else {
231         file.renameTo(new File(targetDir, newName));
232       }
eb2a2d 233       return fname + " umbenannt zu " + newName;
U 234     } else {
235       return "Pfad nicht erlaubt.";
236     }
663ee9 237   }
U 238   
931544 239   public void renameImgFiles(File targetDir, File targetFile, String newName) {
U 240     String alt;
241     String neu;
242     
243     int newdotpos = newName.lastIndexOf(DOT);
244     String newfname = newName.substring(0, newdotpos);
245     String newext = newName.substring(newdotpos);
246     logger.fine("newfname: " + newfname + ", newext: " + newext);
247     
248     String fnameext = targetFile.getName();
249     int dotpos = fnameext.lastIndexOf(DOT);
250     String fname = fnameext.substring(0, dotpos);
251     String ext = fnameext.substring(dotpos);
252     logger.fine("fname: " + fname + ", ext: " + ext);
253     
254     FileFilter fileFilter = new WildcardFileFilter(fname + "*" + ext);
255     File[] files = targetDir.listFiles(fileFilter);
256     for (int i = 0; i < files.length; i++) {
257       alt = files[i].getName();
258       logger.fine("alt: " + alt);
259       if(alt.contains(TNServlet.TN)) {
260         neu = newfname + TNServlet.TN + newext;
261       } else if (alt.contains(TNServlet.KL)) {
262         neu = newfname + TNServlet.KL + newext;
263       } else if(alt.contains(TNServlet.GR)) {
264         neu = newfname + TNServlet.GR + newext;
265       } else if(alt.contains(TNServlet.MT)) {
266         neu = newfname + TNServlet.MT + newext;
267       } else if(alt.contains(TNServlet.SM)) {
268         neu = newfname + TNServlet.SM + newext;
269       } else {
270         neu = newName;
271       }
272       files[i].renameTo(new File(targetDir, neu));        
273       logger.fine("neu: " + neu);
274     }      
275   }
276   
fc1897 277   public String deleteFiles(String relPath, List fileNames) {
U 278     String result = null;
279     try {
280       logger.fine(fileNames.toString());
931544 281       if (!relPath.startsWith(DOT)) {
eb2a2d 282         File targetDir = getTargetDir(relPath);
U 283         for(int i=0; i < fileNames.size(); i++) {
284           Object o = fileNames.get(i);
285           if(o instanceof ArrayList) {
286             ArrayList al = (ArrayList) o;
287             logger.fine(al.get(0).toString());
288             File targetFile = new File(targetDir, al.get(0).toString());
289             logger.fine(targetFile.getAbsolutePath());
290             if(targetFile.isDirectory()) {
291               FileUtils.deleteDirectory(targetFile);
292             } else {
e18175 293                 /*
U 294                 Wenn targetFile mit jpg, jpeg oder png endet, 
295                 muss eine Unterfunktion eine Liste aller Dateien bilden, 
296                 die so heissen, also z.B. alle [Dateiname]*.jpg
297                 */
298               String fname = targetFile.getName().toLowerCase();
299               if(fname.endsWith(TNServlet.JPEG) || fname.endsWith(TNServlet.JPG) || fname.endsWith(TNServlet.PNG)) {
300                 deleteImgFiles(targetDir, targetFile);  
301               } else {
302                 targetFile.delete();
303               }
eb2a2d 304             }
5bfd34 305           }
fc1897 306         }
eb2a2d 307         result = "deleted";
fc1897 308       }
U 309     } catch (Throwable ex) {
310       logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
311     }
312     return result;
313   }
314   
e18175 315   public void deleteImgFiles(File targetDir, File targetFile) {
U 316     String fnameext = targetFile.getName();
931544 317     int dotpos = fnameext.lastIndexOf(DOT);
e18175 318     String fname = fnameext.substring(0, dotpos);
U 319     String ext = fnameext.substring(dotpos);
320     logger.fine("fname: " + fname + ", ext: " + ext);
321     FileFilter fileFilter = new WildcardFileFilter(fname + "*" + ext);
322     File[] files = targetDir.listFiles(fileFilter);
323     for (int i = 0; i < files.length; i++) {
324         logger.fine(files[i].getName());
325         files[i].delete();
326     }      
327   }
328   
9e2964 329   public String copyFiles(String fromPath, String toPath, List fileNames) {
fab629 330     return copyOrMoveFiles(fromPath, toPath, fileNames, OP_COPY);
9e2964 331   }
U 332   
333   public String moveFiles(String fromPath, String toPath, List fileNames) {
fab629 334     return copyOrMoveFiles(fromPath, toPath, fileNames, OP_MOVE);
U 335   }
336   
337   private String copyOrMoveFiles(String fromPath, String toPath, List fileNames, int operation) {
5bfd34 338     String result = null;
U 339     try {
eb2a2d 340       if (!fromPath.startsWith(".")) {
U 341         File srcDir = getTargetDir(fromPath);
342         File targetDir = getTargetDir(toPath);
343         Iterator i = fileNames.iterator();
344         while(i.hasNext()) {
345           Object o = i.next();
346           if (o instanceof ArrayList) {
347             ArrayList al = (ArrayList) o;
348             File srcFile = new File(srcDir, al.get(0).toString());
349             if(srcFile.isDirectory()) {
350               if(operation == OP_MOVE) {
351                 FileUtils.moveDirectoryToDirectory(srcFile, targetDir, false);
352               } else {
353                 FileUtils.copyDirectoryToDirectory(srcFile, targetDir);
354               }
fab629 355             } else {
eb2a2d 356               if(operation == OP_MOVE) {
7b4480 357                 String fname = srcFile.getName().toLowerCase();                
U 358                 if(fname.endsWith(TNServlet.JPEG) || fname.endsWith(TNServlet.JPG) || fname.endsWith(TNServlet.PNG)) {
359                   moveImgFilesToDirectory(srcFile, srcDir, targetDir, false);
360                 } else {
361                   FileUtils.moveFileToDirectory(srcFile, targetDir, false);
362                 }
eb2a2d 363               } else {
U 364                 FileUtils.copyFileToDirectory(srcFile, targetDir);              
365               }
fab629 366             }
5bfd34 367           }
U 368         }
369       }
370     } catch (IOException ex) {
371       logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
372     }
373     return result;
9e2964 374   }
U 375   
7b4480 376   private void moveImgFilesToDirectory(File srcFile, File srcDir, File targetDir, boolean createDestDir) throws IOException {
U 377     String fnameext = srcFile.getName();
378     int dotpos = fnameext.lastIndexOf(DOT);
379     String fname = fnameext.substring(0, dotpos);
380     String ext = fnameext.substring(dotpos);
381     logger.fine("fname: " + fname + ", ext: " + ext);
382     FileFilter fileFilter = new WildcardFileFilter(fname + "*" + ext);
383     File[] files = srcDir.listFiles(fileFilter);
384     for (int i = 0; i < files.length; i++) {
385       logger.fine(files[i].getName());
386       FileUtils.moveFileToDirectory(files[i], targetDir, createDestDir);
387     }      
388   }
389   
47e9d4 390   public FileRef saveTextFileAs(String relPath, String fileName, String contents) {
U 391     FileRef savedFile = null;
392     logger.fine(relPath + " " + fileName);
eb2a2d 393     if (!relPath.startsWith(".")) {
U 394       //FileRef datenRef = getBase();
395       Object p = getRequest().getUserPrincipal();
396       if(p instanceof Principal) {
397         File targetFile = new File(getTargetDir(relPath), fileName);
398         if(targetFile.exists()) {
399           targetFile = getNewFileName(targetFile);
400         } else {
401           targetFile.getParentFile().mkdirs();
402         }
403         saveToFile(targetFile, contents);
47e9d4 404       }
U 405     }
406     return savedFile;
407   }
408   
409   private File getNewFileName(File file) {
410     File dir = file.getParentFile();
411     String targetName = file.getName();
412     logger.fine("targetName: " + targetName);
413     String ext = "";
414     int dotpos = targetName.indexOf(".");
415     if(dotpos > -1) {
416       ext = targetName.substring(dotpos);
417       targetName = targetName.substring(0, dotpos);
418     }
419     logger.fine("targetName: " + targetName + ", ext: " + ext);
420     int i = 1;
421     while(file.exists()) {
422       StringBuffer buf = new StringBuffer();
423       buf.append(targetName);
424       buf.append("-");
425       buf.append(i);
426       if(ext.length() > 0) {
427         buf.append(ext);
428       }
429       file = new File(dir, buf.toString());
430       i++;
431     }
432     logger.fine("new file: " + file.getName());
433     return file;
942d63 434   }  
47e9d4 435   
U 436   private FileRef saveToFile(File targetFile, String contents) {
ea7193 437     FileRef savedFile = null;
e5ff42 438     try {
47e9d4 439       targetFile.createNewFile();
U 440       FileWriter w = new FileWriter(targetFile);
942d63 441       //w.write(StringEscapeUtils.unescapeHtml(contents));
47e9d4 442       w.write(contents);
U 443       w.flush();
444       w.close();
445       savedFile = new FileRef(
446               targetFile.getAbsolutePath(),
447               targetFile.isDirectory(),
448               targetFile.isHidden(),
449               targetFile.lastModified(),
450               targetFile.length());
e5ff42 451     } catch (IOException ex) {
47e9d4 452       logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
U 453     }
454     return savedFile;
455   }
456   
457   public FileRef saveTextFile(String relPath, String fileName, String contents) {
458     FileRef savedFile = null;
459     logger.fine(relPath + " " + fileName);
eb2a2d 460     if (!relPath.startsWith(".")) {    
U 461       //FileRef datenRef = getBase();
462       Object p = getRequest().getUserPrincipal();
463       if(p instanceof Principal) {
464         File targetFile = new File(getTargetDir(relPath), fileName);
465         if(targetFile.exists()) {
466           /*
467             muss delete() sein?
468             pruefen: ueberschreibt der FileWriter den alteen Inhalt oder 
469             entsteht eine unerwuenschte Mischung aus altem und neuem 
470             Inhalt?
471           */
472           targetFile.delete();
473         } else {
474           targetFile.getParentFile().mkdirs();
475         }
476         saveToFile(targetFile, contents);
47e9d4 477       }
e5ff42 478     }
ea7193 479     return savedFile;
U 480   }
438b16 481   
U 482   public String bildVerkleinern(String relPath, String bildName) {
eb2a2d 483     if (!relPath.startsWith(".")) {
U 484       File dir = getTargetDir(relPath);
485       File original = new File(dir, bildName);
486       Bild bild = new Bild();
487       //for (int i = 0; i < Bild.GR.length; i++) {
488
438b16 489       //int gr = bild.getVariantenGroesse(i);
U 490       String ext = "";
491       String nurname = bildName;
492       int dotpos = bildName.indexOf(".");
493       if (dotpos > -1) {
494         ext = bildName.substring(dotpos);
495         nurname = bildName.substring(0, dotpos);
496       }
eb2a2d 497
bb9f8c 498           // 120, 240, 500, 700, 1200
U 499
500       
501       for (int i = 0; i < Bild.GR.length; i++) {
502         StringBuffer buf = new StringBuffer();
503         buf.append(nurname);
504         buf.append(bild.getVariantenName(i));
505         buf.append(ext);
506         File newImgFile = new File(dir, buf.toString());
507         try {
508           Thumbnails.of(original)
509                   .size(bild.getVariantenGroesse(i), bild.getVariantenGroesse(i))
510                   .keepAspectRatio(true)
8a8152 511                   .outputQuality(0.7)
bb9f8c 512                   .toFile(newImgFile);
U 513         } catch (IOException ex) {
514           logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
515         }
516       }
eb2a2d 517       return "ok";
U 518     } else {
519       return "Pfad micht erlaubt.";
520     }
438b16 521   }
6bd2c1 522   
bb9f8c 523   public String bildRotieren(String relPath, String bildName) {
U 524     if (!relPath.startsWith(".")) {
525       File dir = getTargetDir(relPath);
526       File original = new File(dir, bildName);
527
528       String ext = "";
529       String nurname = bildName;
530       int dotpos = bildName.indexOf(".");
531       if (dotpos > -1) {
532         ext = bildName.substring(dotpos);
533         nurname = bildName.substring(0, dotpos);
534       }
535
536       StringBuffer buf = new StringBuffer();
537       buf.append(nurname);
538       buf.append("-rot");
539       buf.append(ext);
540       File newImgFile = new File(dir, buf.toString());
541       
542       logger.fine("original: " + original.getAbsolutePath() + " newImgFile: " + newImgFile.getAbsolutePath());
543
544       try {
545         Thumbnails.of(original)
546                 .scale(1)
547                 .rotate(90)
548                 .toFile(newImgFile);
549       } catch (IOException ex) {
550         logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
551       }
552
553
554       return "ok";
555     } else {
556       return "Pfad micht erlaubt.";
557     }
558   }
af9930 559   
U 560   /* --------- ZIP entpacken ---------------- */
561   
6bd2c1 562   public String extractZipfile(String relPath, String filename) {
eb2a2d 563     String result = null;
U 564     if (!relPath.startsWith(".")) {    
565       try {
566         File targetDir = getTargetDir(relPath);
567         File archive = new File(targetDir, filename);
568         if(extract(archive)) {
569           result = "ok";
570         } else {
571           result = "error while extracting";
572         }
573       } catch(Exception ex) {
574         result = ex.getLocalizedMessage();
575         logger.log(Level.SEVERE, ex.getLocalizedMessage(), ex);
6bd2c1 576       }
U 577     }
578     return result;
579   }
580   
581   /**
582      * extract a given ZIP archive to the folder respective archive resides in
583      * @param archive  the archive to extract
584      * @throws Exception
585      */
586     private boolean extract(File archive) throws Exception {
587         ZipFile zipfile = new ZipFile(archive);
588         Enumeration en = zipfile.entries();
589         while(en.hasMoreElements()) {
590             ZipEntry zipentry = (ZipEntry) en.nextElement();
591             unzip(zipfile, zipentry, archive.getParent());
592         }
593         zipfile.close();
594         return true;
595     }
596
597     /**
598      * unzip a given entry of a given zip file to a given location
599      * @param zipfile  the zip file to read an entry from
600      * @param zipentry  the zip entry to read
601      * @param destPath  the path to the destination location for the extracted content
602      * @throws IOException
603      */
604     private void unzip(ZipFile zipfile, ZipEntry zipentry, String destPath) throws IOException {
605         byte buf[] = new byte[1024];
606         InputStream is = zipfile.getInputStream(zipentry);
607         String outFileName = destPath + File.separator + zipentry.getName();
608         File file = new File(outFileName);
609         if(!zipentry.isDirectory()) {
610             file.getParentFile().mkdirs();
611             if(!file.exists())
612                 file.createNewFile();
613             FileOutputStream fos = new FileOutputStream(file);
614             int i = is.read(buf, 0, 1024);
615             while(i > -1) {
616                 fos.write(buf, 0, i);
617                 i = is.read(buf, 0, 1024);
618             }
619             fos.close();
620             is.close();
621         } else {
622             file.mkdirs();
623         }
624     }
625
af9930 626   /* ------------- Ornder als ZIP packen --------------- */
U 627   
628   public String packFolder(String relPath) {
629     if (!relPath.startsWith(".")) {    
630       try {
631         File targetDir = getTargetDir(relPath);
632         File parentDir = targetDir.getParentFile();
633         StringBuffer fname = new StringBuffer();
634         fname.append(targetDir.getName());
635         fname.append(".zip");
636         File archiveFile = new File(parentDir, fname.toString());
637         FileRef folderToPack = new FileRef(targetDir.getAbsolutePath());
638         FileRef archive = new FileRef(archiveFile.getAbsolutePath());
639         pack(folderToPack, archive);
640         return "ok";
641       } catch(Exception ex) {
642         String result = ex.getLocalizedMessage();
643         logger.log(Level.SEVERE, result, ex);
644         return result;
645       }
646     } else {
647       return "Falsche relative Pfadangabe";
648     }
649   }
650   
651     /**
652      * pack the contents of a given folder into a new ZIP compressed archive
653      * @param folder  the folder to pack
654      * @param archive  the archive to create from the given files
655      * @throws Exception
656      */
657     private boolean pack(FileRef folder, FileRef archive) throws Exception {
658         File file = new File(archive.getAbsolutePath());
659         FileOutputStream fos = new FileOutputStream(file);
660         CheckedOutputStream checksum = new CheckedOutputStream(fos, new Adler32());
661         ZipOutputStream zos = new ZipOutputStream(checksum);
662         pack(zos, folder.getAbsolutePath(), "");
663         zos.flush();
664         zos.finish();
665         zos.close();
666         fos.flush();
667         fos.close();
668         return true;
669     }
670
671     /**
672      * go through the given file structure recursively
673      * @param zipFile  the ZIP file to write to
674      * @param srcDir  the directory to pack during this cycle
675      * @param subDir  the subdirectory to append to names of file entries inside the archive
676      * @throws IOException
677      */
678     private void pack(ZipOutputStream zipFile, String srcDir, String subDir) throws IOException {
679         File[] files = new File(srcDir).listFiles();
680         for(int i = 0; i < files.length; i++) {
681             if(files[i].isDirectory()) {
682                 pack(zipFile, files[i].getAbsolutePath(), subDir + File.separator + files[i].getName());
683             }
684             else {
685                 packFile(zipFile, subDir, files[i]);
686             }
687         }
688     }
689
690     /**
691      * pack a given file
692      * @param zipFile  the ZIP archive to pack to
693      * @param dir  the directory name to append to name of file entry inside archive
694      * @param file  the file to pack
695      * @throws IOException
696      */
697     private void packFile(ZipOutputStream zipFile, String dir, File file) throws IOException
698     {
699         FileInputStream fileinputstream = new FileInputStream(file);
700         byte buf[] = new byte[fileinputstream.available()];
701         fileinputstream.read(buf);
702         String dirWithSlashes = dir.replace('\\', '/');
703         //System.out.println("zipping " + dirWithSlashes + "/" + file.getName());
704         ZipEntry ze = new ZipEntry(dirWithSlashes + "/" + file.getName());
705         ze.setMethod(ZipEntry.DEFLATED);
706         zipFile.putNextEntry(ze);
707         zipFile.write(buf, 0, buf.length);
708         zipFile.closeEntry();
709         fileinputstream.close();
710     }
711
6bd2c1 712   
438b16 713
5efd94 714   /* ---- Hilfsfunktionen ---- */
ea7193 715   
547755 716 }