X-Git-Url: http://git.nikiroo.be/?p=fanfix.git;a=blobdiff_plain;f=src%2Fbe%2Fnikiroo%2Ffanfix%2FLibrary.java;h=f1f7121385faeab1bae5ba686dbdcf2fce993ae5;hp=88228497d8e1b6722e42ca35490006d331fadc9b;hb=70c9b112926f1cf95b2fddd0bb504ab37d6ddd1e;hpb=3b2b638f7e1395702f843b5b19d7959327f604b2

diff --git a/src/be/nikiroo/fanfix/Library.java b/src/be/nikiroo/fanfix/Library.java
index 8822849..f1f7121 100644
--- a/src/be/nikiroo/fanfix/Library.java
+++ b/src/be/nikiroo/fanfix/Library.java
@@ -1,21 +1,27 @@
 package be.nikiroo.fanfix;
 
+import java.awt.image.BufferedImage;
 import java.io.File;
+import java.io.FileFilter;
 import java.io.IOException;
 import java.net.URL;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
+import be.nikiroo.fanfix.bundles.Config;
 import be.nikiroo.fanfix.data.MetaData;
 import be.nikiroo.fanfix.data.Story;
 import be.nikiroo.fanfix.output.BasicOutput;
 import be.nikiroo.fanfix.output.BasicOutput.OutputType;
+import be.nikiroo.fanfix.output.InfoCover;
 import be.nikiroo.fanfix.supported.BasicSupport;
 import be.nikiroo.fanfix.supported.BasicSupport.SupportType;
 import be.nikiroo.fanfix.supported.InfoReader;
+import be.nikiroo.utils.IOUtils;
 import be.nikiroo.utils.Progress;
 
 /**
@@ -23,6 +29,9 @@ import be.nikiroo.utils.Progress;
  * <p>
  * Each {@link Story} object will be associated with a (local to the library)
  * unique ID, the LUID, which will be used to identify the {@link Story}.
+ * <p>
+ * Most of the {@link Library} functions work on either the LUID or a partial
+ * (cover not included) {@link MetaData} object.
  * 
  * @author niki
  */
@@ -54,54 +63,116 @@ public class Library {
 	}
 
 	/**
-	 * List all the known types of stories.
+	 * Refresh the {@link Library}, that is, make sure all stories are loaded.
+	 * 
+	 * @param pg
+	 *            the optional progress reporter
+	 */
+	public void refresh(Progress pg) {
+		getStories(pg);
+	}
+
+	/**
+	 * List all the known types (sources) of stories.
 	 * 
 	 * @return the types
 	 */
-	public List<String> getTypes() {
+	public synchronized List<String> getTypes() {
 		List<String> list = new ArrayList<String>();
-		for (Entry<MetaData, File> entry : getStories().entrySet()) {
-			String storyType = entry.getValue().getParentFile().getName();
+		for (Entry<MetaData, File> entry : getStories(null).entrySet()) {
+			String storyType = entry.getKey().getSource();
 			if (!list.contains(storyType)) {
 				list.add(storyType);
 			}
 		}
 
+		Collections.sort(list);
+		return list;
+	}
+
+	/**
+	 * List all the known authors of stories.
+	 * 
+	 * @return the authors
+	 */
+	public synchronized List<String> getAuthors() {
+		List<String> list = new ArrayList<String>();
+		for (Entry<MetaData, File> entry : getStories(null).entrySet()) {
+			String storyAuthor = entry.getKey().getAuthor();
+			if (!list.contains(storyAuthor)) {
+				list.add(storyAuthor);
+			}
+		}
+
+		Collections.sort(list);
+		return list;
+	}
+
+	/**
+	 * List all the stories of the given author in the {@link Library}, or all
+	 * the stories if NULL is passed as an author.
+	 * <p>
+	 * Cover images not included.
+	 * 
+	 * @param author
+	 *            the author of the stories to retrieve, or NULL for all
+	 * 
+	 * @return the stories
+	 */
+	public synchronized List<MetaData> getListByAuthor(String author) {
+		List<MetaData> list = new ArrayList<MetaData>();
+		for (Entry<MetaData, File> entry : getStories(null).entrySet()) {
+			String storyAuthor = entry.getKey().getAuthor();
+			if (author == null || author.equalsIgnoreCase(storyAuthor)) {
+				list.add(entry.getKey());
+			}
+		}
+
+		Collections.sort(list);
 		return list;
 	}
 
 	/**
 	 * List all the stories of the given source type in the {@link Library}, or
 	 * all the stories if NULL is passed as a type.
+	 * <p>
+	 * Cover images not included.
 	 * 
 	 * @param type
 	 *            the type of story to retrieve, or NULL for all
 	 * 
 	 * @return the stories
 	 */
-	public List<MetaData> getList(String type) {
+	public synchronized List<MetaData> getListByType(String type) {
+		if (type != null) {
+			// convert the type to dir name
+			type = getDir(type).getName();
+		}
+
 		List<MetaData> list = new ArrayList<MetaData>();
-		for (Entry<MetaData, File> entry : getStories().entrySet()) {
+		for (Entry<MetaData, File> entry : getStories(null).entrySet()) {
 			String storyType = entry.getValue().getParentFile().getName();
 			if (type == null || type.equalsIgnoreCase(storyType)) {
 				list.add(entry.getKey());
 			}
 		}
 
+		Collections.sort(list);
 		return list;
 	}
 
 	/**
-	 * Retrieve a {@link File} corresponding to the given {@link Story}.
+	 * Retrieve a {@link File} corresponding to the given {@link Story}, cover
+	 * image not included.
 	 * 
 	 * @param luid
 	 *            the Library UID of the story
 	 * 
 	 * @return the corresponding {@link Story}
 	 */
-	public MetaData getInfo(String luid) {
+	public synchronized MetaData getInfo(String luid) {
 		if (luid != null) {
-			for (Entry<MetaData, File> entry : getStories().entrySet()) {
+			for (Entry<MetaData, File> entry : getStories(null).entrySet()) {
 				if (luid.equals(entry.getKey().getLuid())) {
 					return entry.getKey();
 				}
@@ -119,9 +190,9 @@ public class Library {
 	 * 
 	 * @return the corresponding {@link Story}
 	 */
-	public File getFile(String luid) {
+	public synchronized File getFile(String luid) {
 		if (luid != null) {
-			for (Entry<MetaData, File> entry : getStories().entrySet()) {
+			for (Entry<MetaData, File> entry : getStories(null).entrySet()) {
 				if (luid.equals(entry.getKey().getLuid())) {
 					return entry.getValue();
 				}
@@ -131,6 +202,29 @@ public class Library {
 		return null;
 	}
 
+	/**
+	 * Return the cover image associated to this story.
+	 * 
+	 * @param luid
+	 *            the Library UID of the story
+	 * 
+	 * @return the cover image
+	 */
+	public synchronized BufferedImage getCover(String luid) {
+		MetaData meta = getInfo(luid);
+		if (meta != null) {
+			try {
+				File infoFile = new File(getFile(meta).getPath() + ".info");
+				meta = readMeta(infoFile, true).getKey();
+				return meta.getCover();
+			} catch (IOException e) {
+				Instance.syserr(e);
+			}
+		}
+
+		return null;
+	}
+
 	/**
 	 * Retrieve a specific {@link Story}.
 	 * 
@@ -141,9 +235,9 @@ public class Library {
 	 * 
 	 * @return the corresponding {@link Story} or NULL if not found
 	 */
-	public Story getStory(String luid, Progress pg) {
+	public synchronized Story getStory(String luid, Progress pg) {
 		if (luid != null) {
-			for (Entry<MetaData, File> entry : getStories().entrySet()) {
+			for (Entry<MetaData, File> entry : getStories(null).entrySet()) {
 				if (luid.equals(entry.getKey().getLuid())) {
 					try {
 						SupportType type = SupportType.valueOfAllOkUC(entry
@@ -271,20 +365,21 @@ public class Library {
 	 * @throws IOException
 	 *             in case of I/O error
 	 */
-	public Story save(Story story, String luid, Progress pg) throws IOException {
+	public synchronized Story save(Story story, String luid, Progress pg)
+			throws IOException {
 		// Do not change the original metadata, but change the original story
 		MetaData key = story.getMeta().clone();
 		story.setMeta(key);
 
 		if (luid == null || luid.isEmpty()) {
-			getStories(); // refresh lastId if needed
+			getStories(null); // refresh lastId if needed
 			key.setLuid(String.format("%03d", (++lastId)));
 		} else {
 			key.setLuid(luid);
 		}
 
-		getDir(key).mkdirs();
-		if (!getDir(key).exists()) {
+		getDir(key.getSource()).mkdirs();
+		if (!getDir(key.getSource()).exists()) {
 			throw new IOException("Cannot create library dir");
 		}
 
@@ -296,23 +391,156 @@ public class Library {
 		}
 
 		BasicOutput it = BasicOutput.getOutput(out, true);
-		File file = it.process(story, getFile(key).getPath(), pg);
-		getStories().put(story.getMeta(), file);
+		it.process(story, getFile(key).getPath(), pg);
+
+		// empty cache
+		stories.clear();
 
 		return story;
 	}
 
+	/**
+	 * Delete the given {@link Story} from this {@link Library}.
+	 * 
+	 * @param luid
+	 *            the LUID of the target {@link Story}
+	 * 
+	 * @return TRUE if it was deleted
+	 */
+	public synchronized boolean delete(String luid) {
+		boolean ok = false;
+
+		List<File> files = getFiles(luid);
+		if (!files.isEmpty()) {
+			for (File file : files) {
+				IOUtils.deltree(file);
+			}
+
+			ok = true;
+
+			// clear cache
+			stories.clear();
+		}
+
+		return ok;
+	}
+
+	/**
+	 * Change the type (source) of the given {@link Story}.
+	 * 
+	 * @param luid
+	 *            the {@link Story} LUID
+	 * @param newSourcethe
+	 *            new source
+	 * 
+	 * @return TRUE if the {@link Story} was found
+	 */
+	public synchronized boolean changeType(String luid, String newType) {
+		MetaData meta = getInfo(luid);
+		if (meta != null) {
+			meta.setSource(newType);
+			File newDir = getDir(meta.getSource());
+			if (!newDir.exists()) {
+				newDir.mkdir();
+			}
+
+			List<File> files = getFiles(luid);
+			for (File file : files) {
+				if (file.getName().endsWith(".info")) {
+					try {
+						String name = file.getName().replaceFirst("\\.info$",
+								"");
+						InfoCover.writeInfo(newDir, name, meta);
+						file.delete();
+					} catch (IOException e) {
+						Instance.syserr(e);
+					}
+				} else {
+					file.renameTo(new File(newDir, file.getName()));
+				}
+			}
+
+			// clear cache
+			stories.clear();
+
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Return the list of files/dirs on disk for this {@link Story}.
+	 * <p>
+	 * If the {@link Story} is not found, and empty list is returned.
+	 * 
+	 * @param luid
+	 *            the {@link Story} LUID
+	 * 
+	 * @return the list of {@link File}s
+	 */
+	private List<File> getFiles(String luid) {
+		List<File> files = new ArrayList<File>();
+
+		MetaData meta = getInfo(luid);
+		File file = getStories(null).get(meta);
+
+		if (file != null) {
+			files.add(file);
+
+			String readerExt = getOutputType(meta).getDefaultExtension(true);
+			String fileExt = getOutputType(meta).getDefaultExtension(false);
+
+			String path = file.getAbsolutePath();
+			if (readerExt != null && !readerExt.equals(fileExt)) {
+				path = path.substring(0, path.length() - readerExt.length())
+						+ fileExt;
+				file = new File(path);
+
+				if (file.exists()) {
+					files.add(file);
+				}
+			}
+
+			File infoFile = new File(path + ".info");
+			if (!infoFile.exists()) {
+				infoFile = new File(path.substring(0,
+						path.length() - fileExt.length())
+						+ ".info");
+			}
+
+			if (infoFile.exists()) {
+				files.add(infoFile);
+			}
+
+			String coverExt = "."
+					+ Instance.getConfig().getString(Config.IMAGE_FORMAT_COVER);
+			File coverFile = new File(path + coverExt);
+			if (!coverFile.exists()) {
+				coverFile = new File(path.substring(0,
+						path.length() - fileExt.length())
+						+ coverExt);
+			}
+
+			if (coverFile.exists()) {
+				files.add(coverFile);
+			}
+		}
+
+		return files;
+	}
+
 	/**
 	 * The directory (full path) where the {@link Story} related to this
 	 * {@link MetaData} should be located on disk.
 	 * 
-	 * @param key
-	 *            the {@link Story} {@link MetaData}
+	 * @param type
+	 *            the type (source)
 	 * 
 	 * @return the target directory
 	 */
-	private File getDir(MetaData key) {
-		String source = key.getSource().replaceAll("[^a-zA-Z0-9._+-]", "_");
+	private File getDir(String type) {
+		String source = type.replaceAll("[^a-zA-Z0-9._+-]", "_");
 		return new File(baseDir, source);
 	}
 
@@ -326,68 +554,120 @@ public class Library {
 	 * @return the target
 	 */
 	private File getFile(MetaData key) {
-		String title = key.getTitle().replaceAll("[^a-zA-Z0-9._+-]", "_");
-		return new File(getDir(key), key.getLuid() + "_" + title);
+		String title = key.getTitle();
+		if (title == null) {
+			title = "";
+		}
+		title = title.replaceAll("[^a-zA-Z0-9._+-]", "_");
+		return new File(getDir(key.getSource()), key.getLuid() + "_" + title);
 	}
 
 	/**
 	 * Return all the known stories in this {@link Library} object.
 	 * 
+	 * @param pg
+	 *            the optional progress reporter
+	 * 
 	 * @return the stories
 	 */
-	private Map<MetaData, File> getStories() {
+	private synchronized Map<MetaData, File> getStories(Progress pg) {
+		if (pg == null) {
+			pg = new Progress();
+		} else {
+			pg.setMinMax(0, 100);
+		}
+
 		if (stories.isEmpty()) {
 			lastId = 0;
 
-			String ext = ".info";
-			for (File dir : baseDir.listFiles()) {
-				if (dir.isDirectory()) {
-					for (File file : dir.listFiles()) {
+			File[] dirs = baseDir.listFiles(new FileFilter() {
+				public boolean accept(File file) {
+					return file != null && file.isDirectory();
+				}
+			});
+
+			Progress pgDirs = new Progress(0, 100 * dirs.length);
+			pg.addProgress(pgDirs, 100);
+
+			for (File dir : dirs) {
+				File[] files = dir.listFiles(new FileFilter() {
+					public boolean accept(File file) {
+						return file != null
+								&& file.getPath().toLowerCase()
+										.endsWith(".info");
+					}
+				});
+
+				Progress pgFiles = new Progress(0, files.length);
+				pgDirs.addProgress(pgFiles, 100);
+				pgDirs.setName("Loading from: " + dir.getName());
+
+				for (File file : files) {
+					pgFiles.setName(file.getName());
+					try {
+						Entry<MetaData, File> entry = readMeta(file, false);
 						try {
-							if (file.getPath().toLowerCase().endsWith(ext)) {
-								MetaData meta = InfoReader.readMeta(file);
-								try {
-									int id = Integer.parseInt(meta.getLuid());
-									if (id > lastId) {
-										lastId = id;
-									}
-
-									// Replace .info with whatever is needed:
-									String path = file.getPath();
-									path = path.substring(0, path.length()
-											- ext.length());
-
-									String newExt = getOutputType(meta)
-											.getDefaultExtension();
-
-									file = new File(path + newExt);
-									//
-
-									stories.put(meta, file);
-
-								} catch (Exception e) {
-									// not normal!!
-									Instance.syserr(new IOException(
-											"Cannot understand the LUID of "
-													+ file.getPath() + ": "
-													+ meta.getLuid(), e));
-								}
+							int id = Integer.parseInt(entry.getKey().getLuid());
+							if (id > lastId) {
+								lastId = id;
 							}
-						} catch (IOException e) {
-							// We should not have not-supported files in the
-							// library
-							Instance.syserr(new IOException(
-									"Cannot load file from library: "
-											+ file.getPath(), e));
+
+							stories.put(entry.getKey(), entry.getValue());
+						} catch (Exception e) {
+							// not normal!!
+							throw new IOException(
+									"Cannot understand the LUID of "
+											+ file.getPath() + ": "
+											+ entry.getKey().getLuid(), e);
 						}
+					} catch (IOException e) {
+						// We should not have not-supported files in the
+						// library
+						Instance.syserr(new IOException(
+								"Cannot load file from library: "
+										+ file.getPath(), e));
 					}
+					pgFiles.add(1);
 				}
+
+				pgFiles.setName(null);
 			}
+
+			pgDirs.setName("Loading directories");
 		}
 
 		return stories;
 	}
 
+	private Entry<MetaData, File> readMeta(File infoFile, boolean withCover)
+			throws IOException {
+
+		final MetaData meta = InfoReader.readMeta(infoFile, withCover);
+
+		// Replace .info with whatever is needed:
+		String path = infoFile.getPath();
+		path = path.substring(0, path.length() - ".info".length());
+
+		String newExt = getOutputType(meta).getDefaultExtension(true);
+
+		File targetFile = new File(path + newExt);
+
+		final File ffile = targetFile;
+		return new Entry<MetaData, File>() {
+			public File setValue(File value) {
+				return null;
+			}
+
+			public File getValue() {
+				return ffile;
+			}
+
+			public MetaData getKey() {
+				return meta;
+			}
+		};
+	}
+
 	/**
 	 * Return the {@link OutputType} for this {@link Story}.
 	 *