package be.nikiroo.fanfix.library;
-import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.net.URL;
+import java.net.UnknownHostException;
+import java.util.AbstractMap.SimpleEntry;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
+import java.util.Map.Entry;
import be.nikiroo.fanfix.Instance;
import be.nikiroo.fanfix.data.MetaData;
import be.nikiroo.fanfix.output.BasicOutput;
import be.nikiroo.fanfix.output.BasicOutput.OutputType;
import be.nikiroo.fanfix.supported.BasicSupport;
-import be.nikiroo.fanfix.supported.BasicSupport.SupportType;
+import be.nikiroo.fanfix.supported.SupportType;
+import be.nikiroo.utils.Image;
import be.nikiroo.utils.Progress;
+import be.nikiroo.utils.StringUtils;
/**
* Manage a library of Stories: import, export, list, modify.
* @author niki
*/
abstract public class BasicLibrary {
+ /**
+ * A {@link BasicLibrary} status.
+ *
+ * @author niki
+ */
+ public enum Status {
+ /** The library is ready. */
+ READY,
+ /** The library is invalid (not correctly set up). */
+ INVALID,
+ /** You are not allowed to access this library. */
+ UNAUTORIZED,
+ /** The library is currently out of commission. */
+ UNAVAILABLE,
+ }
+
+ /**
+ * Return a name for this library (the UI may display this).
+ * <p>
+ * Must not be NULL.
+ *
+ * @return the name, or an empty {@link String} if none
+ */
+ public String getLibraryName() {
+ return "";
+ }
+
+ /**
+ * The library status.
+ *
+ * @return the current status
+ */
+ public Status getStatus() {
+ return Status.READY;
+ }
+
/**
* Retrieve the main {@link File} corresponding to the given {@link Story},
* which can be passed to an external reader or instance.
*
* @param luid
* the Library UID of the story
+ * @param pg
+ * the optional {@link Progress}
*
* @return the corresponding {@link Story}
*/
- public abstract File getFile(String luid);
+ public abstract File getFile(String luid, Progress pg);
/**
* Return the cover image associated to this story.
*
* @return the cover image
*/
- public abstract BufferedImage getCover(String luid);
+ public abstract Image getCover(String luid);
+
+ /**
+ * Return the cover image associated to this source.
+ * <p>
+ * By default, return the custom cover if any, and if not, return the cover
+ * of the first story with this source.
+ *
+ * @param source
+ * the source
+ *
+ * @return the cover image or NULL
+ */
+ public Image getSourceCover(String source) {
+ Image custom = getCustomSourceCover(source);
+ if (custom != null) {
+ return custom;
+ }
+
+ List<MetaData> metas = getListBySource(source);
+ if (metas.size() > 0) {
+ return getCover(metas.get(0).getLuid());
+ }
+
+ return null;
+ }
+
+ /**
+ * Return the custom cover image associated to this source.
+ * <p>
+ * By default, return NULL.
+ *
+ * @param source
+ * the source to look for
+ *
+ * @return the custom cover or NULL if none
+ */
+ public Image getCustomSourceCover(@SuppressWarnings("unused") String source) {
+ return null;
+ }
+
+ /**
+ * Fix the source cover to the given story cover.
+ *
+ * @param source
+ * the source to change
+ * @param luid
+ * the story LUID
+ */
+ public abstract void setSourceCover(String source, String luid);
/**
* Return the list of stories (represented by their {@link MetaData}, which
* Invalidate the {@link Story} cache (when the content should be re-read
* because it was changed).
*/
- protected abstract void clearCache();
+ protected void deleteInfo() {
+ deleteInfo(null);
+ }
+
+ /**
+ * Invalidate the {@link Story} cache (when the content is removed).
+ * <p>
+ * All the cache can be deleted if NULL is passed as meta.
+ *
+ * @param luid
+ * the LUID of the {@link Story} to clear from the cache, or NULL
+ * for all stories
+ */
+ protected abstract void deleteInfo(String luid);
+
+ /**
+ * Invalidate the {@link Story} cache (when the content has changed, but we
+ * already have it) with the new given meta.
+ *
+ * @param meta
+ * the {@link Story} to clear from the cache
+ */
+ protected abstract void updateInfo(MetaData meta);
/**
* Return the next LUID that can be used.
throws IOException;
/**
- * Refresh the {@link BasicLibrary}, that is, make sure all stories are
+ * Refresh the {@link BasicLibrary}, that is, make sure all metas are
* loaded.
*
- * @param full
- * force the full content of the stories to be loaded, not just
- * the {@link MetaData}
- *
* @param pg
* the optional progress reporter
*/
- public void refresh(boolean full, Progress pg) {
- if (full) {
- // TODO: progress
- List<MetaData> metas = getMetas(pg);
- for (MetaData meta : metas) {
- getStory(meta.getLuid(), null);
- }
- } else {
- getMetas(pg);
- }
+ public void refresh(Progress pg) {
+ getMetas(pg);
}
/**
return list;
}
+ /**
+ * Return the list of authors, grouped by starting letter(s) if needed.
+ * <p>
+ * If the number of author is not too high, only one group with an empty
+ * name and all the authors will be returned.
+ * <p>
+ * If not, the authors will be separated into groups:
+ * <ul>
+ * <li><tt>*</tt>: any author whose name doesn't contain letters nor numbers
+ * </li>
+ * <li><tt>0-9</tt>: any authors whose name starts with a number</li>
+ * <li><tt>A-C</tt> (for instance): any author whose name starts with
+ * <tt>A</tt>, <tt>B</tt> or <tt>C</tt></li>
+ * </ul>
+ * Note that the letters used in the groups can vary (except <tt>*</tt> and
+ * <tt>0-9</tt>, which may only be present or not).
+ *
+ * @return the authors' names, grouped by letter(s)
+ */
+ public List<Entry<String, List<String>>> getAuthorsGrouped() {
+ int MAX = 20;
+
+ List<Entry<String, List<String>>> groups = new ArrayList<Entry<String, List<String>>>();
+ List<String> authors = getAuthors();
+
+ if (authors.size() <= MAX) {
+ groups.add(new SimpleEntry<String, List<String>>("", authors));
+ return groups;
+ }
+
+ groups.add(new SimpleEntry<String, List<String>>("*", getAuthorsGroup(
+ authors, '*')));
+ groups.add(new SimpleEntry<String, List<String>>("0-9",
+ getAuthorsGroup(authors, '0')));
+
+ for (char car = 'A'; car <= 'Z'; car++) {
+ groups.add(new SimpleEntry<String, List<String>>(Character
+ .toString(car), getAuthorsGroup(authors, car)));
+ }
+
+ // do NOT collapse * and [0-9] with the rest
+ for (int i = 2; i + 1 < groups.size(); i++) {
+ Entry<String, List<String>> now = groups.get(i);
+ Entry<String, List<String>> next = groups.get(i + 1);
+ int currentTotal = now.getValue().size() + next.getValue().size();
+ if (currentTotal <= MAX) {
+ String key = now.getKey().charAt(0) + "-"
+ + next.getKey().charAt(next.getKey().length() - 1);
+ List<String> all = new ArrayList<String>();
+ all.addAll(now.getValue());
+ all.addAll(next.getValue());
+ groups.set(i, new SimpleEntry<String, List<String>>(key, all));
+ groups.remove(i + 1);
+ i--;
+ }
+ }
+
+ for (int i = 0; i < groups.size(); i++) {
+ if (groups.get(i).getValue().size() == 0) {
+ groups.remove(i);
+ i--;
+ }
+ }
+
+ return groups;
+ }
+
+ /**
+ * Get all the authors that start with the given character:
+ * <ul>
+ * <li><tt>*</tt>: any author whose name doesn't contain letters nor numbers
+ * </li>
+ * <li><tt>0</tt>: any authors whose name starts with a number</li>
+ * <li><tt>A</tt> (any capital latin letter): any author whose name starts
+ * with <tt>A</tt></li>
+ * </ul>
+ *
+ * @param authors
+ * the full list of authors
+ * @param car
+ * the starting character, <tt>*</tt>, <tt>0</tt> or a capital
+ * letter
+ * @return the authors that fulfill the starting letter
+ */
+ private List<String> getAuthorsGroup(List<String> authors, char car) {
+ List<String> accepted = new ArrayList<String>();
+ for (String author : authors) {
+ char first = '*';
+ for (int i = 0; first == '*' && i < author.length(); i++) {
+ String san = StringUtils.sanitize(author, true, true);
+ char c = san.charAt(i);
+ if (c >= '0' && c <= '9') {
+ first = '0';
+ } else if (c >= 'a' && c <= 'z') {
+ first = (char) (c - 'a' + 'A');
+ } else if (c >= 'A' && c <= 'Z') {
+ first = c;
+ }
+ }
+
+ if (first == car) {
+ accepted.add(author);
+ }
+ }
+
+ return accepted;
+ }
+
/**
* List all the stories in the {@link BasicLibrary}.
* <p>
* @return the corresponding {@link Story} or NULL if not found
*/
public synchronized Story getStory(String luid, Progress pg) {
- // TODO: pg
if (pg == null) {
pg = new Progress();
}
+ Progress pgGet = new Progress();
+ Progress pgProcess = new Progress();
+
+ pg.setMinMax(0, 2);
+ pg.addProgress(pgGet, 1);
+ pg.addProgress(pgProcess, 1);
+
Story story = null;
for (MetaData meta : getMetas(null)) {
if (meta.getLuid().equals(luid)) {
- File file = getFile(luid);
+ File file = getFile(luid, pgGet);
+ pgGet.done();
try {
SupportType type = SupportType.valueOfAllOkUC(meta
.getType());
URL url = file.toURI().toURL();
if (type != null) {
- story = BasicSupport.getSupport(type).process(url, pg);
+ story = BasicSupport.getSupport(type, url) //
+ .process(pgProcess);
+
+ // Because we do not want to clear the meta cache:
+ meta.setCover(story.getMeta().getCover());
+ meta.setResume(story.getMeta().getResume());
+ story.setMeta(meta);
+ //
} else {
throw new IOException("Unknown type: " + meta.getType());
}
} catch (IOException e) {
// We should not have not-supported files in the
// library
- Instance.syserr(new IOException(
- "Cannot load file from library: " + file, e));
+ Instance.getTraceHandler().error(
+ new IOException("Cannot load file from library: "
+ + file, e));
} finally {
+ pgProcess.done();
pg.done();
}
*
* @return the imported {@link Story}
*
+ * @throws UnknownHostException
+ * if the host is not supported
* @throws IOException
* in case of I/O error
*/
public Story imprt(URL url, Progress pg) throws IOException {
+ if (pg == null)
+ pg = new Progress();
+
+ pg.setMinMax(0, 1000);
+ Progress pgProcess = new Progress();
+ Progress pgSave = new Progress();
+ pg.addProgress(pgProcess, 800);
+ pg.addProgress(pgSave, 200);
+
BasicSupport support = BasicSupport.getSupport(url);
if (support == null) {
- throw new IOException("URL not supported: " + url.toString());
+ throw new UnknownHostException("" + url);
+ }
+
+ Story story = save(support.process(pgProcess), pgSave);
+ pg.done();
+
+ return story;
+ }
+
+ /**
+ * Import the story from one library to another, and keep the same LUID.
+ *
+ * @param other
+ * the other library to import from
+ * @param luid
+ * the Library UID
+ * @param pg
+ * the optional progress reporter
+ *
+ * @throws IOException
+ * in case of I/O error
+ */
+ public void imprt(BasicLibrary other, String luid, Progress pg)
+ throws IOException {
+ Progress pgGetStory = new Progress();
+ Progress pgSave = new Progress();
+ if (pg == null) {
+ pg = new Progress();
}
- return save(support.process(url, pg), null);
+ pg.setMinMax(0, 2);
+ pg.addProgress(pgGetStory, 1);
+ pg.addProgress(pgSave, 1);
+
+ Story story = other.getStory(luid, pgGetStory);
+ if (story != null) {
+ story = this.save(story, luid, pgSave);
+ pg.done();
+ } else {
+ pg.done();
+ throw new IOException("Cannot find story in Library: " + luid);
+ }
}
/**
pg.addProgress(pgOut, 1);
}
- BasicOutput out = BasicOutput.getOutput(type, true);
+ BasicOutput out = BasicOutput.getOutput(type, false, false);
if (out == null) {
throw new IOException("Output type not supported: " + type);
}
*/
public synchronized Story save(Story story, String luid, Progress pg)
throws IOException {
+
+ Instance.getTraceHandler().trace(
+ this.getClass().getSimpleName() + ": saving story " + luid);
+
// Do not change the original metadata, but change the original story
MetaData meta = story.getMeta().clone();
story.setMeta(meta);
meta.setLuid(luid);
}
- if (getInfo(luid) != null) {
+ if (luid != null && getInfo(luid) != null) {
delete(luid);
}
- doSave(story, pg);
- clearCache();
+ story = doSave(story, pg);
+
+ updateInfo(story.getMeta());
+
+ Instance.getTraceHandler().trace(
+ this.getClass().getSimpleName() + ": story saved (" + luid
+ + ")");
return story;
}
* in case of I/O error
*/
public synchronized void delete(String luid) throws IOException {
+ Instance.getTraceHandler().trace(
+ this.getClass().getSimpleName() + ": deleting story " + luid);
+
doDelete(luid);
- clearCache();
+ deleteInfo(luid);
+
+ Instance.getTraceHandler().trace(
+ this.getClass().getSimpleName() + ": story deleted (" + luid
+ + ")");
}
/**
git://git.nikiroo.be / fanfix.git / blobdiff