Version 1.6.1
[fanfix.git] / src / be / nikiroo / fanfix / library / BasicLibrary.java
CommitLineData
e42573a0 1package be.nikiroo.fanfix.library;
68e2c6d2
NR
2
3import java.awt.image.BufferedImage;
4import java.io.File;
5import java.io.IOException;
6import java.net.URL;
7import java.util.ArrayList;
8import java.util.Collections;
9import java.util.List;
10
e42573a0 11import be.nikiroo.fanfix.Instance;
68e2c6d2
NR
12import be.nikiroo.fanfix.data.MetaData;
13import be.nikiroo.fanfix.data.Story;
14import be.nikiroo.fanfix.output.BasicOutput;
15import be.nikiroo.fanfix.output.BasicOutput.OutputType;
16import be.nikiroo.fanfix.supported.BasicSupport;
17import be.nikiroo.fanfix.supported.BasicSupport.SupportType;
18import be.nikiroo.utils.Progress;
19
20/**
21 * Manage a library of Stories: import, export, list, modify.
22 * <p>
23 * Each {@link Story} object will be associated with a (local to the library)
24 * unique ID, the LUID, which will be used to identify the {@link Story}.
25 * <p>
26 * Most of the {@link BasicLibrary} functions work on a partial (cover
27 * <b>MAY</b> not be included) {@link MetaData} object.
28 *
29 * @author niki
30 */
31abstract public class BasicLibrary {
32 /**
33 * Retrieve the main {@link File} corresponding to the given {@link Story},
34 * which can be passed to an external reader or instance.
35 * <p>
36 * Do <b>NOT</b> alter this file.
37 *
38 * @param luid
39 * the Library UID of the story
40 *
41 * @return the corresponding {@link Story}
42 */
43 public abstract File getFile(String luid);
44
45 /**
46 * Return the cover image associated to this story.
47 *
48 * @param luid
49 * the Library UID of the story
50 *
51 * @return the cover image
52 */
53 public abstract BufferedImage getCover(String luid);
54
14b57448
NR
55 /**
56 * Return the cover image associated to this source.
57 * <p>
58 * By default, return the cover of the first story with this source.
59 *
60 * @param source
61 * the source
62 *
63 * @return the cover image or NULL
64 */
65 public BufferedImage getSourceCover(String source) {
66 List<MetaData> metas = getListBySource(source);
67 if (metas.size() > 0) {
68 return getCover(metas.get(0).getLuid());
69 }
70
71 return null;
72 }
73
74 /**
75 * Fix the source cover to the given story cover.
76 *
77 * @param source
78 * the source to change
79 * @param luid
80 * the story LUID
81 */
82 public abstract void setSourceCover(String source, String luid);
83
68e2c6d2
NR
84 /**
85 * Return the list of stories (represented by their {@link MetaData}, which
86 * <b>MAY</b> not have the cover included).
87 *
88 * @param pg
89 * the optional {@link Progress}
90 *
91 * @return the list (can be empty but not NULL)
92 */
93 protected abstract List<MetaData> getMetas(Progress pg);
94
95 /**
96 * Invalidate the {@link Story} cache (when the content should be re-read
97 * because it was changed).
98 */
99 protected abstract void clearCache();
100
101 /**
102 * Return the next LUID that can be used.
103 *
104 * @return the next luid
105 */
106 protected abstract int getNextId();
107
108 /**
109 * Delete the target {@link Story}.
110 *
111 * @param luid
112 * the LUID of the {@link Story}
113 *
114 * @throws IOException
115 * in case of I/O error or if the {@link Story} wa not found
116 */
117 protected abstract void doDelete(String luid) throws IOException;
118
119 /**
120 * Actually save the story to the back-end.
121 *
122 * @param story
123 * the {@link Story} to save
124 * @param pg
125 * the optional {@link Progress}
126 *
127 * @return the saved {@link Story} (which may have changed, especially
128 * regarding the {@link MetaData})
129 *
130 * @throws IOException
131 * in case of I/O error
132 */
133 protected abstract Story doSave(Story story, Progress pg)
134 throws IOException;
135
136 /**
137 * Refresh the {@link BasicLibrary}, that is, make sure all stories are
138 * loaded.
139 *
140 * @param full
141 * force the full content of the stories to be loaded, not just
142 * the {@link MetaData}
143 *
144 * @param pg
145 * the optional progress reporter
146 */
147 public void refresh(boolean full, Progress pg) {
148 if (full) {
149 // TODO: progress
150 List<MetaData> metas = getMetas(pg);
151 for (MetaData meta : metas) {
152 getStory(meta.getLuid(), null);
153 }
154 } else {
155 getMetas(pg);
156 }
157 }
158
159 /**
160 * List all the known types (sources) of stories.
161 *
162 * @return the sources
163 */
164 public synchronized List<String> getSources() {
165 List<String> list = new ArrayList<String>();
166 for (MetaData meta : getMetas(null)) {
167 String storySource = meta.getSource();
168 if (!list.contains(storySource)) {
169 list.add(storySource);
170 }
171 }
172
173 Collections.sort(list);
174 return list;
175 }
176
177 /**
178 * List all the known authors of stories.
179 *
180 * @return the authors
181 */
182 public synchronized List<String> getAuthors() {
183 List<String> list = new ArrayList<String>();
184 for (MetaData meta : getMetas(null)) {
185 String storyAuthor = meta.getAuthor();
186 if (!list.contains(storyAuthor)) {
187 list.add(storyAuthor);
188 }
189 }
190
191 Collections.sort(list);
192 return list;
193 }
194
195 /**
196 * List all the stories in the {@link BasicLibrary}.
197 * <p>
198 * Cover images not included.
199 *
200 * @return the stories
201 */
202 public synchronized List<MetaData> getList() {
203 return getMetas(null);
204 }
205
206 /**
207 * List all the stories of the given source type in the {@link BasicLibrary}
208 * , or all the stories if NULL is passed as a type.
209 * <p>
210 * Cover images not included.
211 *
212 * @param type
213 * the type of story to retrieve, or NULL for all
214 *
215 * @return the stories
216 */
217 public synchronized List<MetaData> getListBySource(String type) {
218 List<MetaData> list = new ArrayList<MetaData>();
219 for (MetaData meta : getMetas(null)) {
220 String storyType = meta.getSource();
221 if (type == null || type.equalsIgnoreCase(storyType)) {
222 list.add(meta);
223 }
224 }
225
226 Collections.sort(list);
227 return list;
228 }
229
230 /**
231 * List all the stories of the given author in the {@link BasicLibrary}, or
232 * all the stories if NULL is passed as an author.
233 * <p>
234 * Cover images not included.
235 *
236 * @param author
237 * the author of the stories to retrieve, or NULL for all
238 *
239 * @return the stories
240 */
241 public synchronized List<MetaData> getListByAuthor(String author) {
242 List<MetaData> list = new ArrayList<MetaData>();
243 for (MetaData meta : getMetas(null)) {
244 String storyAuthor = meta.getAuthor();
245 if (author == null || author.equalsIgnoreCase(storyAuthor)) {
246 list.add(meta);
247 }
248 }
249
250 Collections.sort(list);
251 return list;
252 }
253
254 /**
255 * Retrieve a {@link MetaData} corresponding to the given {@link Story},
256 * cover image <b>MAY</b> not be included.
257 *
258 * @param luid
259 * the Library UID of the story
260 *
261 * @return the corresponding {@link Story}
262 */
263 public synchronized MetaData getInfo(String luid) {
264 if (luid != null) {
265 for (MetaData meta : getMetas(null)) {
266 if (luid.equals(meta.getLuid())) {
267 return meta;
268 }
269 }
270 }
271
272 return null;
273 }
274
275 /**
276 * Retrieve a specific {@link Story}.
277 *
278 * @param luid
279 * the Library UID of the story
280 * @param pg
281 * the optional progress reporter
282 *
283 * @return the corresponding {@link Story} or NULL if not found
284 */
285 public synchronized Story getStory(String luid, Progress pg) {
286 // TODO: pg
287 if (pg == null) {
288 pg = new Progress();
289 }
290
291 Story story = null;
292 for (MetaData meta : getMetas(null)) {
293 if (meta.getLuid().equals(luid)) {
294 File file = getFile(luid);
295 try {
296 SupportType type = SupportType.valueOfAllOkUC(meta
297 .getType());
298 URL url = file.toURI().toURL();
299 if (type != null) {
300 story = BasicSupport.getSupport(type).process(url, pg);
301 } else {
302 throw new IOException("Unknown type: " + meta.getType());
303 }
304 } catch (IOException e) {
305 // We should not have not-supported files in the
306 // library
307 Instance.syserr(new IOException(
308 "Cannot load file from library: " + file, e));
309 } finally {
310 pg.done();
311 }
312
313 break;
314 }
315 }
316
317 return story;
318 }
319
320 /**
321 * Import the {@link Story} at the given {@link URL} into the
322 * {@link BasicLibrary}.
323 *
324 * @param url
325 * the {@link URL} to import
326 * @param pg
327 * the optional progress reporter
328 *
329 * @return the imported {@link Story}
330 *
331 * @throws IOException
332 * in case of I/O error
333 */
334 public Story imprt(URL url, Progress pg) throws IOException {
335 BasicSupport support = BasicSupport.getSupport(url);
336 if (support == null) {
337 throw new IOException("URL not supported: " + url.toString());
338 }
339
340 return save(support.process(url, pg), null);
341 }
342
343 /**
344 * Export the {@link Story} to the given target in the given format.
345 *
346 * @param luid
347 * the {@link Story} ID
348 * @param type
349 * the {@link OutputType} to transform it to
350 * @param target
351 * the target to save to
352 * @param pg
353 * the optional progress reporter
354 *
355 * @return the saved resource (the main saved {@link File})
356 *
357 * @throws IOException
358 * in case of I/O error
359 */
360 public File export(String luid, OutputType type, String target, Progress pg)
361 throws IOException {
362 Progress pgGetStory = new Progress();
363 Progress pgOut = new Progress();
364 if (pg != null) {
365 pg.setMax(2);
366 pg.addProgress(pgGetStory, 1);
367 pg.addProgress(pgOut, 1);
368 }
369
fa4dcafe 370 BasicOutput out = BasicOutput.getOutput(type, false);
68e2c6d2
NR
371 if (out == null) {
372 throw new IOException("Output type not supported: " + type);
373 }
374
375 Story story = getStory(luid, pgGetStory);
376 if (story == null) {
377 throw new IOException("Cannot find story to export: " + luid);
378 }
379
380 return out.process(story, target, pgOut);
381 }
382
383 /**
384 * Save a {@link Story} to the {@link BasicLibrary}.
385 *
386 * @param story
387 * the {@link Story} to save
388 * @param pg
389 * the optional progress reporter
390 *
391 * @return the same {@link Story}, whose LUID may have changed
392 *
393 * @throws IOException
394 * in case of I/O error
395 */
396 public Story save(Story story, Progress pg) throws IOException {
397 return save(story, null, pg);
398 }
399
400 /**
401 * Save a {@link Story} to the {@link BasicLibrary} -- the LUID <b>must</b>
402 * be correct, or NULL to get the next free one.
403 * <p>
404 * Will override any previous {@link Story} with the same LUID.
405 *
406 * @param story
407 * the {@link Story} to save
408 * @param luid
409 * the <b>correct</b> LUID or NULL to get the next free one
410 * @param pg
411 * the optional progress reporter
412 *
413 * @return the same {@link Story}, whose LUID may have changed
414 *
415 * @throws IOException
416 * in case of I/O error
417 */
418 public synchronized Story save(Story story, String luid, Progress pg)
419 throws IOException {
420 // Do not change the original metadata, but change the original story
421 MetaData meta = story.getMeta().clone();
422 story.setMeta(meta);
423
424 if (luid == null || luid.isEmpty()) {
425 meta.setLuid(String.format("%03d", getNextId()));
426 } else {
427 meta.setLuid(luid);
428 }
429
430 if (getInfo(luid) != null) {
431 delete(luid);
432 }
14b57448 433
68e2c6d2
NR
434 doSave(story, pg);
435
436 clearCache();
437
438 return story;
439 }
440
441 /**
442 * Delete the given {@link Story} from this {@link BasicLibrary}.
443 *
444 * @param luid
445 * the LUID of the target {@link Story}
446 *
447 * @throws IOException
448 * in case of I/O error
449 */
450 public synchronized void delete(String luid) throws IOException {
451 doDelete(luid);
452 clearCache();
453 }
454
455 /**
456 * Change the type (source) of the given {@link Story}.
457 *
458 * @param luid
459 * the {@link Story} LUID
460 * @param newSource
461 * the new source
462 * @param pg
463 * the optional progress reporter
464 *
465 * @throws IOException
466 * in case of I/O error or if the {@link Story} was not found
467 */
468 public synchronized void changeSource(String luid, String newSource,
469 Progress pg) throws IOException {
470 MetaData meta = getInfo(luid);
471 if (meta == null) {
472 throw new IOException("Story not found: " + luid);
473 }
474
475 meta.setSource(newSource);
476 saveMeta(meta, pg);
477 }
478
479 /**
480 * Save back the current state of the {@link MetaData} (LUID <b>MUST NOT</b>
481 * change) for this {@link Story}.
482 * <p>
483 * By default, delete the old {@link Story} then recreate a new
484 * {@link Story}.
485 * <p>
486 * Note that this behaviour can lead to data loss.
487 *
488 * @param meta
489 * the new {@link MetaData} (LUID <b>MUST NOT</b> change)
490 * @param pg
491 * the optional {@link Progress}
492 *
493 * @throws IOException
494 * in case of I/O error or if the {@link Story} was not found
495 */
496 protected synchronized void saveMeta(MetaData meta, Progress pg)
497 throws IOException {
498 if (pg == null) {
499 pg = new Progress();
500 }
501
502 Progress pgGet = new Progress();
503 Progress pgSet = new Progress();
504 pg.addProgress(pgGet, 50);
505 pg.addProgress(pgSet, 50);
506
507 Story story = getStory(meta.getLuid(), pgGet);
508 if (story == null) {
509 throw new IOException("Story not found: " + meta.getLuid());
510 }
511
512 delete(meta.getLuid());
513
514 story.setMeta(meta);
515 save(story, meta.getLuid(), pgSet);
516
517 pg.done();
518 }
519}