file-cms.git - Ulrich Hilger Code Repository

collectFiles als API-Methode hinzugefuegt

ulrich

2018-04-03 e2f0bbb60123a12b84d86062789c2fb605f37dba

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