Klassenbiliothek fuer Dateiverwaltung
ulrich
13 hours ago 1be785f6df00e3f36c00b58a2d0c623733c74621
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
/*
  fm - File management class library
  Copyright (C) 2024  Ulrich Hilger
 
  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 <https://www.gnu.org/licenses/>.
 */
package de.uhilger.fm;
 
import java.io.File;
import java.io.IOException;
import java.nio.file.DirectoryStream;
import java.nio.file.Files;
import java.nio.file.Path;
 
/**
 * Verschieben und Kopieren von Dateien und Ordnern
 * 
 * Handhabung von Bilddateien: 
 * 
 * Fuer jede Datei mit Endung jpg, jpeg und png werden alle Varianten wie zum Beispiel 
 * dateiname.jpg, dateiname_kl.jpg, dateiname_gr.jpg, dateiname_gr_b64.jpg usw. 
 * beruecksichtigt.
 *
 * @author Ulrich Hilger, 15. Janaur 2024
 */
public class Mover extends FileHelper {
 
  public static final int OP_COPY = 1;
  public static final int OP_MOVE = 2;
  
  /**
   * Dateien und Ordner kopieren
   * 
   * @param fromPath der Pfad zur Quelle  der Kopieraktion
   * @param toPath der Pfad zum Ziel der Kopieraktion
   * @param fileNames die Liste der Dateien und Ordner, die kopiert werden sollen
   * @param base der Basispfad, gegen den fromPath und toPath aufgeloest werden sollen
   * @throws IOException wenn etwas schief geht
   */
  public void copy(String fromPath, String toPath, String[] fileNames, String base) 
          throws IOException {
    copyOrMoveFiles(fromPath, toPath, fileNames, OP_COPY, base);
  }
  
  /**
   * Dateien und Ordner verschieben
   * 
   * @param fromPath der Pfad zur Quelle  der Verschiebeaktion
   * @param toPath der Pfad zum Ziel der Verschiebeaktion
   * @param fileNames die Liste der Dateien und Ordner, die verschoben werden sollen
   * @param base der Basispfad, gegen den fromPath und toPath aufgeloest werden sollen
   * @throws IOException wenn etwas schief geht
   */
  public void move(String fromPath, String toPath, String[] fileNames, String base) 
          throws IOException {
    copyOrMoveFiles(fromPath, toPath, fileNames, OP_MOVE, base);    
  }
  
  /**
   * Dateien und Ordner verschieben oder kopieren
   * 
   * @param fromPath der Pfad zur Quelle  der Verschiebe- oder Kopieraktion
   * @param toPath der Pfad zum Ziel der Verschiebe- oder Kopieraktion
   * @param fileNames die Liste der Dateien und Ordner, die verschoben oder kopiert werden sollen
   * @param operation die gewuenschte Dateioperation, OP_COPY oder OP_MOVE
   * @param base der Basispfad, gegen den fromPath und toPath aufgeloest werden sollen
   * @throws IOException wenn etwas schief geht
   */
  private void copyOrMoveFiles(String fromPath, String toPath, String[] fileNames, 
          int operation, String base) throws IOException {
    //String result = null;
    File srcDir = new File(base, fromPath);
    File targetDir = new File(base, toPath);
    for (String fileName : fileNames) {
      File srcFile = new File(srcDir, fileName);
      //logger.fine("srcFile: " + srcFile);
      if (srcFile.isDirectory()) {
        //logger.fine("srcFile is directory.");
        FileOpsVisitor bearbeiter = new FileOpsVisitor();
        bearbeiter.setTargetDir(targetDir.toPath());
        bearbeiter.setOperation(operation);
        Files.walkFileTree(srcFile.toPath(), bearbeiter);
      } else {
        Path source = srcFile.toPath();
        File destFile = targetDir.toPath().resolve(source.getFileName()).toFile();
        if (destFile.exists()) {
          destFile = getNewFileName(destFile);
        }
        if (operation == OP_MOVE) {
          String fname = srcFile.getName().toLowerCase();
          if (fname.endsWith(ImageFileFilter.JPEG)
                  || fname.endsWith(ImageFileFilter.JPG)
                  || fname.endsWith(ImageFileFilter.PNG)) {
            moveImgFilesToDirectory(srcFile, srcDir, targetDir/*, false*/);
          } else {
            Files.move(source, destFile.toPath());
          }
        } else {
          Files.copy(source, destFile.toPath());
        }
      }
    }
    //return result;
  }
 
  /**
   * Eine Bilddatei mit allen Varianten verschieben oder kopieren
   * 
   * Fuer jede Datei mit Endung jpg, jpeg und png werden alle Varianten wie zum Beispiel 
   * dateiname.jpg, dateiname_kl.jpg, dateiname_gr.jpg, dateiname_gr_b64.jpg usw. 
   * beruecksichtigt, also dateiname*.jpg.
   * 
   * @param srcFile die Bilddatei, deren Varianten beruecksichtigt werden sollen
   * @param srcDir der Herkunftsort
   * @param targetDir der Zielort
   * @throws IOException wenn etwas schief geht
   */
  private void moveImgFilesToDirectory(File srcFile, File srcDir, File targetDir/*, 
          boolean createDestDir*/) throws IOException {
    String fnameext = srcFile.getName();
    int dotpos = fnameext.lastIndexOf(".");
    String fname = fnameext.substring(0, dotpos);
    String ext = fnameext.substring(dotpos);
    //logger.fine("fname: " + fname + ", ext: " + ext);
    Path targetPath = targetDir.toPath();
    DirectoryStream<Path> stream = Files.newDirectoryStream(srcDir.toPath(), fname + "*" + ext); 
                                                //"*.{txt,doc,pdf,ppt}"
    for (Path path : stream) {
      //logger.fine(path.getFileName().toString());
      //Files.delete(path);
      Files.move(path, targetPath.resolve(path.getFileName()));
    }
    stream.close();
  }
 
}